想象你是一名新入职的“数字翻译官”，今天的客户很特别：左边坐着一位只会说“嗒嗒嘟”的 CPU 机器人，右边坐着只会说人话的产品经理。你的任务，是把同一条数字消息在两种“语言”之间来回翻译。更妙的是，翻译界还流传着两种“速记方言”——八进制和十六进制——用来把机器人那串又长又拗口的“嗒嘟”缩写成几行清爽的笔记。 你可能会问：数字还有语言？当然有。我们从小用十进制数数，可计算机只认二进制的“电流通断”；而八进制、十六进制，则是人类为了偷懒发明的“缩写本”。好消息是，这些语言之间的翻译规则极其简单：一种叫“按权展开法”，像用汇率把外币换成人民币；一种叫“分组对应法”，像拿着速记词典把长句子拆成单词来查。读完这篇文章，你就能徒手完成任意进制互转，还能看懂内存地址、颜色代码和文件权限背后的数字玄机。

岗位关联

进制互转是看懂计算机底层数据的“通用语言”，无论是调试模型权重、分析内存布局，还是准备算法面试，这套技能都是 AI 工程师的基本功。

目录
  1. 可视化演示
  2. 进制初识：先认识三种“数语”
  3. 二进制揭秘：机器人的母语
  4. 八进制与十六进制：人类发明的速记符
  5. 按权展开法：用汇率换算听懂任意进制
  6. 除2取余法：十进制换二进制的拆票术
  7. 分组对应法：二进制与速记符的直连通道
  8. 反推还原法：把速记符展开成二进制
  9. 实战演练：存储、地址与面试考点
  10. AI 应用场景
  11. Python 演示
  12. 常见误区
  13. 面试题

可视化演示

动态演示轻松搞懂进制互转的核心机制，通过开始/执行/监控/完成四种模式展示关键概念与交互流程。

本节配有交互动效（进入视口后自动加载，约 3KB）。

轻松搞懂进制互转：镜像仓库 镜像仓库架构与Registry Harbor私有仓库搭建与配置 核心机制可视化 轻松搞懂进制互转整体架构与关键组件

进制初识：先认识三种“数语”

翻译官上岗第一课，不是背单词，而是搞清楚世界上到底有几种“数字语言”。就像同样是“三”这个数量，中文念 sān，英语念 three，日语念 san——发音不同，指的是同一个东西。进制也是同样的道理：十进制、二进制、八进制、十六进制，是同一批数字的四种“方言”，差别只在两点：允许使用哪些“字母”，以及数到几就要进位。

进制的核心是“逢某进一”。十进制数码是 0~9，数到 9 再加 1 就要进位成 10；二进制数码只有 0 和 1，所以 1 再加 1 就进位成 10（读作“一零”，不是“十”）。八进制数码 0~7，十六进制则是 0~9 加上 A、B、C、D、E、F 六个“外来字母”。每种进制都有一套完整的三要素：底数（就是逢几进一的“几”）、数码（允许出现的字符集合）、位权（每个位置代表的真实大小）。

一套进制里，每个位置都藏着一个“权重”：从右往左数，第 0 位的位权是 1，第 1 位是底数本身，第 2 位是底数的平方……这就是“位权”的通俗理解。翻译官在笔记本上画下三张名片：十进制写着“逢十进一，位权是 10 的幂”，二进制写着“逢二进一，位权是 2 的幂”，十六进制写着“逢十六进一，位权是 16 的幂”。有了这三张名片，后面的互转就有章可循了。

二进制揭秘：机器人的母语

接待 CPU 机器人时你会发现，它的世界里只有两个发音：“嗒”表示有电流，“嘟”表示没电流。你对着它喊“三”，它一脸茫然；你只好说“嗒嘟”（也就是 11），它立刻心领神会。这就是为什么计算机不用十进制——因为电流的“通”和“断”最容易被物理世界稳定地制造和识别，造出十个稳定状态的电路又贵又容易出错。

二进制里每一位数字叫做一个“比特”（bit），取自 binary digit 的缩写。8 个比特组合成一个“字节”（Byte），字节是计算机存储容量的基本计数单位。一个字节恰好能表示 256 种不同的组合，这就像 8 个“嗒嘟开关”的开关组合，从全关到全开一共有 2 的 8 次方种状态。

认识了比特和字节，翻译官终于明白：给机器人传话，不管是数字、字母还是标点，最终都要拆成 8 位一组的“嗒嘟串”。而这个“嗒嘟串”又长又难记，赶紧学学人类发明的速记符吧。

1 Byte=8 bit,28=256\displaystyle 1\,\text{Byte}=8\,\text{bit},\qquad 2^8=256
一个字节能装下 256 种不同的“暗号”：0 到 255 的整数，或者一个英文字母，或者一个颜色分量。
  1. 字节的组成1 个字节由 8 个比特拼成，比特是存储的最小单位，就像“元”是人民币的最小单位。
    1 Byte=8 bit\displaystyle 1\,\text{Byte}=8\,\text{bit}
  2. 组合总数每个比特有 0、1 两种状态，8 个比特相互独立，所以组合数是 2 自乘 8 次。
    28=2×2×2×2×2×2×2×2=256\displaystyle 2^8=2\times 2\times 2\times 2\times 2\times 2\times 2\times 2=256
  3. 含义延伸256 种组合足够给英文字母、数字和标点各分配一个专属“暗号”，这就是 ASCII 编码能工作的基础。
    0∼255 对应 256 种状态\displaystyle 0\sim 255\ \text{对应}\ 256\ \text{种状态}

八进制与十六进制：人类发明的速记符

每次给机器人传话都要念一长串“嗒嘟”，念到第八位同事已经睡着了。于是翻译界发明了两种速记符：把每 3 个“嗒嘟”打包成一个符号，就是八进制；把每 4 个“嗒嘟”打包成一个符号，就是十六进制。这就像把“世界贸易组织”缩写成“WTO“，把”中华人民共和国“缩写成”中国”，信息一点没丢，写起来却清爽太多。

为什么偏偏是 3 个和 4 个一组？因为 8 = 2³，16 = 2⁴。3 个二进制位恰好能组合出 8 种状态（000 到 111），正好对应八进制的 0~7 这 8 个数字；4 个二进制位能组合出 16 种状态（0000 到 1111），正好对应十六进制的 0~F。这种“一位对多位”的整齐对应关系，是进制转换里最漂亮的捷径——不需要任何除法，只需要查表。

翻译官把这两条公式贴在工位上，从此再也不怕长串二进制了：看到 16 位地址，先四四分组写成 4 个十六进制字符，一目了然。不过这还是纸上功夫，真正的大招是下面两种核心转换法。

8=23,16=24\displaystyle 8=2^{3},\qquad 16=2^{4}
因为 8 和 16 都是 2 的整数次幂，二进制与它们之间才能做到“ 1 对 3”、“ 1 对 4”的无缝直连。
  1. 八进制的底数8 等于 2 的三次方，所以 3 个二进制位能表示 0 到 7，恰好对应一位八进制数字。
    8=23=2×2×2\displaystyle 8=2^{3}=2\times 2\times 2
  2. 十六进制的底数16 等于 2 的四次方，4 个二进制位能表示 0 到 15，恰好对应一位十六进制数字。
    16=24=2×2×2×2\displaystyle 16=2^{4}=2\times 2\times 2\times 2
  3. 速记的依据底数之间的幂次关系，决定了二进制与这些进制之间“分组翻译”的可行性，这是分组对应法的理论基础。

按权展开法：用汇率换算听懂任意进制

想象你要去机器人的国家出差，手里攥着一沓外币。怎么知道值多少人民币？很简单：每张纸币的面额乘以当天的汇率，然后全部加起来。按权展开法干的就是这件事——把任意进制的每一位数字，乘上它所在位置的“汇率”（也就是位权），最后求和。这个“汇率”完全由底数和位置决定：第 i 位的汇率就是底数的 i 次方。

以二进制数 11010 为例，从右往左给每个位置编号：第 0 位是 0，第 1 位是 1，第 2 位是 0，第 3 位是 1，第 4 位是 1。二进制底数是 2，所以对应的汇率依次是 2⁰=1、2¹=2、2²=4、2³=8、2⁴=16。把每一位数字乘上汇率再累加：0×1 + 1×2 + 0×4 + 1×8 + 1×16 = 26。瞧，11010 在十进制里就是 26。

学会了按权展开，任何进制在你面前都像贴了价签的外币：看到 32₈，算 3×8+2×1=26；看到 1A₁₆，算 1×16+10×1=26。外币换人民币的手艺练熟了，接下来学学反向操作——人民币怎么换成机器人的“嗒嘟币”。

N=∑i=0n−1di×bi\displaystyle N=\sum_{i=0}^{n-1} d_i \times b^{i}
字母 b 是底数（进制），数字 dᵢ 是第 i 位上的数字，bⁱ 就是这一位的“汇率”。所有位加起来，就是十进制结果。
  1. 认识底数 bb 是这套“数语”的基数，十进制 b=10、二进制 b=2，它决定了每一位的“汇率底线”。
    b=2, 8, 10, 16\displaystyle b=2,\ 8,\ 10,\ 16
  2. 确定第 i 位数字 dᵢ从最右边开始把位置编号为第 0 位、第 1 位……数字就像外币上的面额“1 元、5 元、10 元”。
    di×bi\displaystyle d_i \times b^{i}
  3. 累加求和把每一张“外币”都换算成人民币，最后全部相加，得到的就是十进制结果。
    N=dn−1bn−1+⋯+d1b1+d0b0\displaystyle N=d_{n-1}b^{n-1}+\cdots +d_{1}b^{1}+d_{0}b^{0}

除2取余法：十进制换二进制的拆票术

现在方向反过来：产品经理递给你 26 元人民币，要求换成机器人的“嗒嘟币”——也就是二进制。可惜机器人国家的汇率很古怪，它只收面额为 2 的幂的“纸币”，而且 2 元纸币是最大单位。怎么办？用“拆票法”：先把 26 元按 2 元一包打包，能打 13 包，剩 0 元零钱，记下 0；再把 13 包按 2 包一组再打包，能打 6 组，剩 1 包，记下 1；继续打包：6 包按 2 分组打 3 组剩 0，3 组打 1 组剩 1，1 组打 0 组剩 1。把记下的零钱从最后一次向前倒着念，就是 11010。

数学上这叫做“除 2 取余”：不断用 2 去除当前数，记下余数，用商继续除，直到商为 0。公式可以写成递归的形式，每一步的商和余数都清清楚楚。

这节最容易翻车的就是“倒序”。记住翻译官的顺口溜：零钱先写是低位，大票后出摆前面。拆完别忘了验算：把 11010 用按权展开法算回去，16+8+2=26，完美对上。接下来进入最爽快的直连通道。

Nk=⌊Nk−1/2⌋,dk=Nk−1 mod 2\displaystyle N_{k}=\left\lfloor N_{k-1}/2 \right\rfloor,\qquad d_{k}=N_{k-1}\bmod 2
N 是当前待除的数，⌊⌋ 表示只取整数商，mod 表示取余数。每除一次产生一位二进制余数，把所有余数从后往前排，就是二进制结果。
  1. 取商递推把当前数除以 2，只保留整数部分作为下一轮的新数，小数部分扔掉。
    Nk=⌊Nk−1/2⌋\displaystyle N_{k}=\left\lfloor N_{k-1}/2 \right\rfloor
  2. 取余记录除完剩下的余数，就是这一轮“拆票”拆出来的零钱，非 0 即 1。
    dk=Nk−1 mod 2\displaystyle d_{k}=N_{k-1}\bmod 2
  3. 倒序拼接先拆出来的余数是低位（右边的位），后拆出来的是高位（左边的位），所以必须倒着念才正确。
    26=110102 （余数0,1,0,1,1 倒序）\displaystyle 26=11010_{2}\ \text{（余数} 0,1,0,1,1 \text{ 倒序）}

分组对应法：二进制与速记符的直连通道

你已经会了“外币换人民币”和“人民币换嗒嘟币”，但有个更省事的小路：二进制和八进制、十六进制之间根本不用经过十进制这个“中转站”！既然 8=2³、16=2⁴，那就直接把二进制串从右往左分组：每 3 位一组查八进制表，每 4 位一组查十六进制表。就像翻译官拿到了速记词典，看到一句话不再逐字翻译，而是按词查。

以 11010 为例转八进制：从右往左每 3 位划一组，最左边不满 3 位就单独成组，得到 11 和 010 两组。查表：11 = 3，010 = 2，于是 11010₂ = 32₈。再转十六进制：从右往左每 4 位一组，得到 1 和 1010 两组，查表：1 = 1，1010 = A，所以 11010₂ = 1A₁₆。验证一下：32₈ = 3×8+2=26，1A₁₆ = 1×16+10=26，三个数完全相等！

十六进制就是“8421 法则”：四位一组的位权从高到低是 8、4、2、1，算出的 10~15 分别写成 A~F。对比一下绕道十进制要多算好几步，分组法三步出结果。现在反向也来一条快车道。

g=d2×4+d1×2+d0×1\displaystyle g=d_{2}\times 4+d_{1}\times 2+d_{0}\times 1
g 是三位二进制组换算出来的一位八进制数字。三位二进制 d₂d₁d₀ 的位权正好是 4、2、1，这就是“421 法则”。
  1. 三位一组从右往左每 3 个二进制位切成一组，最左边不足 3 位时保持原样不补零。
    11010→11 ∣ 010\displaystyle 11010 \rightarrow 11\ |\ 010
  2. 按 421 加权每组内从高到低位权是 4、2、1，把为 1 的位权加起来，得到 0~7 的八进制数字。
    010=0×4+1×2+0×1=2\displaystyle 010=0\times 4+1\times 2+0\times 1=2
  3. 串联书写把每一组算出的八进制数字从左到右拼接，高位组写前面，低位组写后面。
    328=3×8+2=26  验证通过\displaystyle 32_{8}=3\times 8+2=26\ \text{ 验证通过}

反推还原法：把速记符展开成二进制

从速记符转回“嗒嘟串”同样不用除法，只需要把刚才的分组过程倒着走：一位八进制数字展开成 3 位二进制，一位十六进制数字展开成 4 位二进制，最后把所有片段拼起来。这就像拿到缩写“WTO“，在词典里查出全称”World Trade Organization”，再拼成完整句子。

以 1A₁₆ 转二进制为例：查表得 1 → 0001，A → 1010，拼接得到 00011010，去掉最前面的两个前导零，就是 11010。以 32₈ 为例：3 → 011，2 → 010，拼接为 011010，去掉前导零后同样是 11010。

翻译官的词典里因此多了两条反向条目。到这里，二进制、八进制、十六进制、十进制四个方向的全套互转你都掌握了。最后去实战现场检验一下身手。

(Oi)10=(b2b1b0)2,(Hi)10=(b3b2b1b0)2\displaystyle (O_i)_{10}=(b_2 b_1 b_0)_2,\qquad (H_i)_{10}=(b_3 b_2 b_1 b_0)_2
左边的 Oᵢ 和 Hᵢ 是八进制、十六进制的某一位数字，右边的 b 是展开后的二进制位。一位八进制拆三位，一位十六进制拆四位。
  1. 八进制拆三位每个八进制数字 0~7 都对应一个三位二进制串，如 3 → 011。
    310=0×4+1×2+1×1=0112\displaystyle 3_{10}=0\times 4+1\times 2+1\times 1=011_2
  2. 十六进制拆四位每个十六进制数字 0~F 都对应一个四位二进制串，如 A → 1010。
    1010=1×8+0×4+1×2+0×1=10102\displaystyle 10_{10}=1\times 8+0\times 4+1\times 2+0\times 1=1010_2
  3. 拼接去前导零把拆出的二进制片段按顺序拼接，最左边多余的 0 不影响数值，可以去掉。
    0001 1010→11010\displaystyle 0001\,1010 \rightarrow 11010

实战演练：存储、地址与面试考点

翻译官正式上岗，第一天的任务清单全是“速记符”的身影：内存地址是一串十六进制，图片颜色是 #FFA500 这样的十六进制三元组，Linux 文件权限是 755 这样的八进制数，甚至网卡 MAC 地址也是 12 个十六进制字符。为什么大家这么爱用八、十六进制？因为它们和二进制直连，又能缩短书写长度——0x7FFD 比 0111 1111 1111 1101 好写一万倍。

存储单位换算中也到处是进制：1 KB 不是 1000 字节，而是 1024 字节，因为 1024 = 2¹⁰。模型文件动辄几百 MB、几个 GB，这些数字背后都是 2 的幂在滚动。AI 工程师分析一个 ONNX 权重文件时，用十六进制查看器打开，看到的每一段字节流都要能快速识别出魔数、维度、量化参数。

面试官最爱考的场景也在这里：快速说出 0xFF 是多少（255）、把 10110110 转十六进制（B6）、把 26 转二进制（11010）。只要把按权展开、除 2 取余、分组查表这三板斧练熟，任何进制互转都是几十秒的口算题。

1 KB=210 B=1024 B\displaystyle 1\,\text{KB}=2^{10}\,\text{B}=1024\,\text{B}
计算机存储单位之间的进率是 1024（2 的 10 次方）而不是 1000，这是由二进制的天然结构决定的。
  1. 千字节定义1 KB 是 1024 个字节，不是一千个字节，因为计算机按 2 的幂组织存储。
    1 KB=210 B\displaystyle 1\,\text{KB}=2^{10}\,\text{B}
  2. 指数展开2¹⁰ 就是 10 个 2 连乘，等于 1024。
    210=1024\displaystyle 2^{10}=1024
  3. 容量递推1 MB = 1024 KB，1 GB = 1024 MB，每次换算都是再乘一个 2¹⁰。
    1 MB=1024 KB=220 B\displaystyle 1\,\text{MB}=1024\,\text{KB}=2^{20}\,\text{B}

AI 应用场景

模型权重文件的十六进制“体检”

阶段：数据处理与调试

解决的问题：AI 工程师拿到一个二进制权重文件（.bin），文件头用文本编辑器打开全是乱码。传统做法是盲试解析，容易把魔数（文件类型标识）和版本号读错位，导致模型加载失败且难以排查。

具体案例：用十六进制查看器打开 ONNX 权重文件，前 8 个字节是固定魔数，按字节读成十六进制即可快速确认文件类型；再往后偏移 4 字节是版本号，用按权展开法把十六进制转成十进制版本。整个过程像翻译官查词典一样，先利用十六进制速记符快速定位，再用按权展开法算出真实数值。

INT8 量化模型的存储换算

阶段：模型压缩与部署

解决的问题：把 FP32 模型量化为 INT8，模型体积理论能缩小到四分之一。但新手常误以为 1 MB 是 1000 KB，按十进制算容量，导致对显存占用预估偏差 2.4%，部署时爆显存。

具体案例：1 亿参数的模型，FP32 每个参数 4 字节，共 4 亿字节；换算成 MB 要除以 2²⁰（约 104 万）而不是 100 万。熟悉 2 的幂换算后，口算即可得出约 381 MB，量化成 INT8 后约 95 MB，部署规划心里有底。

嵌入式 AI 芯片的寄存器调试

阶段：推理部署与调试

解决的问题：在嵌入式 AI 芯片上排查算子计算错误，需要读取寄存器的二进制值。寄存器每一位都代表一个开关（如第 3 位表示是否启用量化），用二进制看最直观，但 32 位太长；用十六进制看又难以对应到具体位。

具体案例：调试时把寄存器值 0x0C 转成二进制 00001100，立刻定位到第 2 位和第 3 位为 1——正是量化使能和数据对齐开关。借助二进制与十六进制的四位分组直连，工程师可以秒级完成位级判断，不用反复按计算器。

Python 演示

python59 行
# 进制转换工具箱：手写实现按权展开法、除2取余法和分组对应法DIGITS = "0123456789ABCDEF" def to_decimal(s, base):    """按权展开法：任意进制字符串转十进制整数"""    value = 0    n = len(s)    for i, ch in enumerate(s):        d = DIGITS.index(ch)        value += d * base ** (n - 1 - i)    return value def to_binary(n):    """除2取余法：十进制整数转二进制字符串，余数倒序拼接"""    if n == 0:        return "0"    rems = []    while n > 0:        rems.append(str(n % 2))        n //= 2    return "".join(reversed(rems)) def binary_to_oct(bits):    """分组对应法：二进制字符串转八进制，三位一组"""    while len(bits) % 3 != 0:        bits = "0" + bits    groups = [bits[i:i + 3] for i in range(0, len(bits), 3)]    return "".join(str(int(g, 2)) for g in groups) def binary_to_hex(bits):    """分组对应法：二进制字符串转十六进制，四位一组"""    while len(bits) % 4 != 0:        bits = "0" + bits    groups = [bits[i:i + 4] for i in range(0, len(bits), 4)]    return "".join(DIGITS[int(g, 2)] for g in groups) def oct_to_binary(octal):    """反推还原法：八进制字符串转二进制，一位拆三位"""    table = {"0": "000", "1": "001", "2": "010", "3": "011",             "4": "100", "5": "101", "6": "110", "7": "111"}    return "".join(table[ch] for ch in octal).lstrip("0") or "0" def hex_to_binary(hex_str):    """反推还原法：十六进制字符串转二进制，一位拆四位"""    table = {c: format(i, "04b") for i, c in enumerate(DIGITS)}    return "".join(table[ch] for ch in hex_str).lstrip("0") or "0" def main():    n = 26    b = to_binary(n)    print("十进制 26 -> 二进制", b)    print("按权展开验证:", to_decimal(b, 2))    print("二进制 -> 八进制", binary_to_oct(b))    print("二进制 -> 十六进制", binary_to_hex(b))    print("八进制 32 -> 二进制", oct_to_binary("32"))    print("十六进制 1A -> 二进制", hex_to_binary("1A")) if __name__ == "__main__":    main()
目的：用纯手写函数完整复现正文讲的四种换算方法，跑一遍即可看到 26 在三种进制间的完整旅行。
  1. value += d * base ** (n - 1 - i)这就是按权展开的“汇率兑换”：第 i 位的数字乘上底数的（n-1-i）次方。
  2. while n > 0:只要商还没变成 0，就继续“拆票”，每轮除 2 取一个余数。
  3. rems.append(str(n % 2))记录本轮余数，这就是拆出来的“零钱”。
  4. "".join(reversed(rems))余数必须倒序拼接，这是除 2 取余最容易错的一步。
  5. while len(bits) % 3 != 0:给二进制串前面补 0，补到长度能被 3 整除，方便整齐分组。
  6. "".join(str(int(g, 2)) for g in groups)每组三位二进制用内置的 int 函数按 2 进制求值，等价于手算 421 法则。
  7. table = {c: format(i, "04b") for i, c in enumerate(DIGITS)}生成“十六进制数字 → 四位二进制”的速记词典，format 的 "04b" 表示补零到 4 位的二进制格式。

常见误区

误区我一直以为二进制就是只由 0 和 1 组成的数，八进制就是只由 0~7 组成的数。所以看到 11010 我就知道它是二进制，看到 32 我就以为它一定是十进制。

正解进制不是数字的长相，而是“如何计数”的规则。同一个量 26，十进制写作 26，二进制写作 11010，十六进制写作 1A——它们长得完全不同，却是同一个数。就像“三”和"three"指同一个数量。判断一个数属于哪种进制，必须看它的计数规则和标注（如下标或前缀），不能只看外观。11010 如果没有标注，它可以是二进制、十进制甚至任意大于 2 的进制。

为何常见：我们从小只接触十进制，先入为主地把“数字的书写形式”当成了“数的本质”，忽略了进位规则才是进制的灵魂。

误区我把 26 一直除以 2，依顺序记下余数 0、1、0、1、1，然后从头念出来，得到 01011。用按权展开一验算：0×16+1×8+0×4+1×2+1=11，完全对不上，当场懵了。

正解余数必须“倒序”读：第一次除 2 得到的余数是最低位，最后一次除出来的余数才是最高位。26 的余数序列是 0、1、0、1、1，倒过来是 11010，验算 16+8+2=26 正确。可以这样记：先记下来的是“零钱”，零钱要放最右边；后记下来的是“大票”，大票摆最左边。每次除完随手画一个从下往上念的箭头，就能避免顺序搞反。

为何常见：我们习惯了从上往下书写的顺序，记录顺序自然地等于输出顺序。但除 2 取余的产出顺序恰好和书写顺序相反，不养成“倒序”的肌肉记忆就特别容易错。

误区我觉得二进制转八进制应该先把二进制转成十进制，再从十进制转八进制，就像出国换钱要先换成美元当中间货币。结果算 11010 转八进制，先算 26 再除 8，绕了一大圈还算错了。

正解因为 8=2³、16=2⁴，二进制与八进制、十六进制之间存在“分组直连”的捷径，完全不需要经过十进制：三位一组查表就是八进制（11010→011 010→32₈），四位一组查表就是十六进制（0001 1010→1A₁₆）。十进制只在这些进制互相转换时才是“必然中转站”。识别“底数是 2 的幂”这一信号，就能立刻切换成分组法，又快又不容易错。

为何常见：“中间货币”的思维惯性太强，加上对 2 的幂关系不够敏感，很多人没发现二进制和八、十六进制之间的天然分组结构。

误区按权展开 11010 时，我从左往右数，第一位乘 2¹，第二位乘 2²……结果算出来 1×2+1×4+0×8+1×16+0×32=22，和正确答案 26 差了 4。

正解位权编号必须从最右边开始，从 0 数起：最右位是 2⁰=1，往左依次是 2¹、2²、2³、2⁴。11010 正确展开是 0×1+1×2+0×4+1×8+1×16=26。直觉理解：最右边的位是“个位”，它的汇率永远是 1，也就是底数的 0 次方。这就像人民币的个位、十位、百位，编号从最右边数才是对的。

为何常见：生活语言里说“第一位”都是从头开始数，而数学公式的角标从 0 开始，这个编号偏移藏在细节里，最容易让人栽跟头。

面试题

Q1. 十进制数 26 转换为二进制是多少？

单选题 · easy

  • A.11000
  • B.11010← 正确答案
  • C.10110
  • D.11100

答案：B。用除 2 取余法：26÷2 余 0，13÷2 余 1，6÷2 余 0，3÷2 余 1，1÷2 余 1，余数序列 0、1、0、1、1 倒序得 11010。可以快速验证：16+8+2=26。其他选项展开后分别是 24、22、28，都不等于 26。

Q2. 二进制数 11010 转换为十进制是多少？

单选题 · easy

  • A.24
  • B.26← 正确答案
  • C.28
  • D.30

答案：B。按权展开法，从右往左位权依次是 1、2、4、8、16，计算 0×1+1×2+0×4+1×8+1×16=26。就像把每张“外币”按汇率换成人民币再相加，11010 的十进制值就是 26。

Q3. 二进制数转换为八进制数时，应从右往左每几位分成一组？

单选题 · easy

  • A.2 位一组
  • B.3 位一组← 正确答案
  • C.4 位一组
  • D.8 位一组

答案：B。八进制的底数是 8，而 8=2³，所以 3 个二进制位恰好对应一位八进制数字（000~111 对应 0~7）。这是“三位一组的魔法”。4 位一组对应的是十六进制，2 位一组没有任何进制与之对应。

Q4. 十六进制数 1A 转换为十进制是多少？

单选题 · mid

  • A.24
  • B.26← 正确答案
  • C.28
  • D.30

答案：B。十六进制中 A 代表 10。按权展开：A 在最右位乘 16⁰=1，得 10；1 在第二位乘 16¹=16，得 16。16+10=26。注意 1A₁₆ 和 26₁₀、11010₂、32₈ 是同一个数的四种写法。

Q5. 用除 2 取余法把 26 转二进制，依次记下的余数是 0、1、0、1、1，正确的二进制结果是？

单选题 · mid

  • A.01011
  • B.10101
  • C.11010← 正确答案
  • D.01110

答案：C。除 2 取余的余数必须倒序阅读：先记下的是最低位，后记下的是最高位。余数序列 0、1、0、1、1 倒过来是 11010。可以这样记：先写的是“零钱”放右边，后写的是“大票”放左边。验算 16+8+2=26 确认无误。

Q6. 八进制数 32 转换为二进制是多少？

单选题 · mid

  • A.11100
  • B.10110
  • C.11010← 正确答案
  • D.10010

答案：C。用反推还原法：一位八进制数字拆成三位二进制，3→011，2→010，拼接得 011010，去掉前导零得到 11010。验证：11010 按权展开等于 16+8+2=26，而 32₈=3×8+2=26，两者相等。

Q7. 下列关于计算机存储单位的说法，正确的有？

多选题 · mid

  • A.一字节等于八位← 正确答案
  • B.1KB等于1024字节← 正确答案
  • C.位是最小存储单位← 正确答案
  • D.1MB等于1000KB

答案：ABC。1 字节（Byte）=8 位（bit），位是存储的最小单位，A 和 C 正确。存储单位之间的进率是 1024 而不是 1000，因为 1024=2¹⁰，所以 1KB=1024B、1MB=1024KB，B 正确、D 错误。这是二进制结构在存储体系中的直接体现。

Q8. 二进制数 10110110 转换为十六进制是多少？

单选题 · hard

  • A.B6← 正确答案
  • B.6B
  • C.D6
  • D.6D

答案：A。四位一组从右往左分组：1011 和 0110。查“8421 法则”：1011=8+2+1=11，即十六进制的 B；0110=4+2=6。拼接得 B6。注意高四位在左、低四位在右，顺序不能颠倒，否则就会错选 6B。

Q9. 下列关于十六进制的说法，正确的有？

多选题 · mid

  • A.数码含有A到F六个字母← 正确答案
  • B.一位十六进制对四位二进制← 正确答案
  • C.内存地址常用十六进制表示← 正确答案
  • D.CPU直接执行十六进制指令

答案：ABC。十六进制数码是 0~9 加 A~F，A 代表 10、F 代表 15，A 正确；16=2⁴，一位十六进制对应四位二进制，B 正确；内存地址用十六进制书写简洁，C 正确；CPU 直接执行的是二进制机器码，十六进制只是给人看的速记符，D 错误。

Q10. 关于按权展开法，下列说法正确的有？

多选题 · hard

  • A.底数就是该进制的基数← 正确答案
  • B.最右位的位权恒为一← 正确答案
  • C.位权是底数的位置次方← 正确答案
  • D.只适合二进制转十进制

答案：ABC。按权展开法中，底数是进制的基数（十进制为 10、二进制为 2），A 正确；最右边是第 0 位，位权 = 底数⁰ = 1，B 正确；第 i 位的位权是底数的 i 次方，C 正确；该方法适用于任意进制转十进制，包括八进制、十六进制，D 错误。它就像一套通用的“汇率兑换”规则，不局限于某一种货币。