企业官网建设流程全解析

1. 为什么我不推荐你直接用内置函数做进制转换

很多人第一次接触进制转换，脑子里蹦出来的第一个念头就是bin()、hex()、int()三件套。日常写业务代码，这么干完全没问题，Python内置函数底层是C实现的，又快又稳。但如果你正在准备技术面试、想搞懂计算机底层的数据表示、或者需要处理一些内置函数覆盖不到的场景（比如26进制这种非标准进制），那手写一遍转换逻辑就是绕不过去的坎。

我自己就吃过这个亏。早些年做一个短链接生成的小工具，需要把自增ID压缩成更短的字符串，当时想当然地用了十六进制，结果发现长度还是不够短。后来才意识到，用26个字母做进制，同样的数值能比十六进制少占不少位数。但Python内置函数里根本没有26进制的转换方法，只能自己动手写。也就是从那时候起，我把二进制、十进制、十六进制、26进制的转换逻辑从头到尾捋了一遍，踩了不少坑，也总结了一些书本上不会讲的细节。

这篇文章就是把这些经验完整地分享出来。不管你是刚学Python的新手，还是工作几年但一直没深究过进制转换的老手，看完之后都能自己写出稳定可靠的转换函数。我会从最基础的数学原理讲起，然后逐个实现四种进制的互转，最后重点聊一聊实际编码中容易翻车的边界情况和性能优化技巧。

2. 进制转换的数学本质：按权展开与短除法

2.1 所有进制转换都逃不开的两个核心操作

进制转换看起来花样很多，二进制转十进制、十进制转十六进制、十六进制转二进制……但剥开表象，底层只有两个基本操作：按权展开求和和短除法取余。

按权展开求和，解决的是“任意进制转十进制”的问题。比如二进制数1011，它代表的十进制值就是每一位数字乘以该位的权重再求和。权重是基数的幂次，从右往左依次是基数的0次方、1次方、2次方……所以1011展开就是1×2³ + 0×2² + 1×2¹ + 1×2⁰ = 8 + 0 + 2 + 1 = 11。这个逻辑对任何进制都成立，十六进制、26进制都一样，只是基数不同而已。

短除法取余，解决的是“十进制转任意进制”的问题。把十进制数不断除以目标基数，每次取余数作为当前位的数字，直到商为0，最后把余数倒序排列。比如十进制11转二进制：11÷2=5余1，5÷2=2余1，2÷2=1余0，1÷2=0余1，余数倒过来就是1011。这个方法的正确性可以用数学归纳法证明，但作为从业者，你只需要记住“除基取余，倒序排列”这八个字就够了。

注意：短除法得到的余数顺序是低位在前、高位在后，所以最后必须反转。这是新手最容易忘记的一步，我见过不少人在这一步翻车。

2.2 为什么理解了这两个操作就能通吃所有进制

因为任意进制之间的转换，都可以拆成“源进制转十进制”加“十进制转目标进制”两步。比如二进制转十六进制，先按权展开把二进制转成十进制，再用短除法把十进制转成十六进制。虽然实际工程中我们会用更高效的直接映射法（比如四位二进制对应一位十六进制），但作为理解原理的起点，这个两步法是最清晰的。

26进制稍微特殊一点，因为它不是2的幂次，没法像二进制和十六进制那样做位对齐的直接映射。所以26进制的转换必须老老实实走“转十进制再转目标进制”的路线。这也是为什么很多人在处理26进制时容易出错——他们试图套用二进制和十六进制的经验，结果发现根本对不上。

理解了这两个核心操作，你就有了一个通用的思维框架。后面不管遇到什么奇怪的进制，你都能自己推导出转换方法，而不是死记硬背。

3. 二进制与十进制的互转实现

3.1 十进制转二进制：短除法的Python落地

先来看最基础的十进制转二进制。按照短除法的思路，代码逻辑很直接：

def dec_to_bin(n): if n == 0: return "0" digits = [] while n > 0: digits.append(str(n % 2)) n //= 2 return "".join(reversed(digits))

这段代码有几个细节值得说。第一，我单独处理了n == 0的情况，因为如果直接进循环，0 % 2 = 0，0 // 2 = 0，会陷入死循环。这是新手写短除法时最常见的bug。第二，我用digits列表收集余数，最后用reversed反转再拼接，比字符串拼接效率高得多。Python里字符串是不可变对象，每次拼接都会创建新对象，数据量大时性能差距非常明显。

第三，这里只处理了正整数。如果传入负数，n > 0的条件直接不成立，会返回空字符串。实际使用中，负数的二进制表示涉及补码，那是另一个话题了。如果你的场景需要处理负数，建议先取绝对值转换，再手动加上负号，或者明确使用补码逻辑。

3.2 二进制转十进制：按权展开的两种写法

二进制转十进制，按权展开的思路有两种实现方式。第一种是从右往左遍历，维护一个不断翻倍的权重：

def bin_to_dec(s): result = 0 power = 1 for ch in reversed(s): if ch == '1': result += power power *= 2 return result

第二种是从左往右遍历，每次把之前的结果乘以2再加上当前位：

def bin_to_dec_v2(s): result = 0 for ch in s: result = result * 2 + int(ch) return result

两种写法结果一样，但第二种更简洁，也更符合“秦九韶算法”的思想。我实测下来，第二种写法在Python里略快一点，因为少了一次reversed和一次乘法赋值。不过差距很小，选哪种主要看个人习惯。

这里有个容易忽略的点：输入校验。如果用户传入的字符串包含非0和1的字符，上面的代码会静默产生错误结果。比如int('2')在第二种写法里会返回2，导致最终结果完全错误。所以生产环境里一定要加校验：

def bin_to_dec_safe(s): if not all(ch in '01' for ch in s): raise ValueError(f"非法二进制字符串: {s}") result = 0 for ch in s: result = result * 2 + int(ch) return result

提示：all()配合生成器表达式是Python里做字符校验的常用套路，比写循环加标志位简洁得多。

4. 十六进制转换中的字母映射陷阱

4.1 十进制转十六进制：余数超过9怎么办

十六进制的基数是16，但我们的数字符号只有0到9十个。所以当余数落在10到15之间时，必须映射成字母A到F。这是十六进制转换和二进制转换最大的区别，也是新手最容易卡住的地方。

HEX_CHARS = "0123456789ABCDEF" def dec_to_hex(n): if n == 0: return "0" digits = [] while n > 0: digits.append(HEX_CHARS[n % 16]) n //= 16 return "".join(reversed(digits))

这里我用了一个字符串HEX_CHARS做映射表，索引就是余数。n % 16的结果是0到15，正好对应HEX_CHARS的下标。这种“查表法”比写一堆if-elif判断优雅得多，而且性能更好。同样的思路可以用在任何需要数字到字符映射的场景。

有个细节要注意：十六进制字母用大写还是小写？Python内置的hex()函数输出小写，但很多文档和协议里习惯用大写。我的建议是统一用大写，因为大写字母在视觉上更容易和数字区分，特别是在长字符串里。当然，如果你的项目有明确规范，跟着规范走就行。

4.2 十六进制转十进制：字母到数字的反向映射

反向转换时，需要把字母A到F还原成10到15。最直接的方法是查表：

def hex_to_dec(s): s = s.upper() result = 0 for ch in s: if '0' <= ch <= '9': val = ord(ch) - ord('0') elif 'A' <= ch <= 'F': val = ord(ch) - ord('A') + 10 else: raise ValueError(f"非法十六进制字符: {ch}") result = result * 16 + val return result

这里用ord()函数做字符到ASCII码的转换，再通过减法得到数值。ord('0')是48，ord('9')是57，所以ord(ch) - ord('0')就能把字符'0'到'9'映射成0到9。同理，ord('A')是65，ord(ch) - ord('A') + 10把'A'到'F'映射成10到15。

这种写法的好处是不依赖字典查找，纯算术运算，速度很快。但可读性稍差，如果你更看重代码清晰度，用字典映射也完全可以：

HEX_MAP = {ch: i for i, ch in enumerate("0123456789ABCDEF")}

一行代码就能生成映射字典，然后HEX_MAP[ch]直接取值。字典查找是O(1)的，性能上不会有明显差距。我个人在性能敏感的场景用ord()算术法，在业务代码里用字典法，兼顾速度和可读性。

4.3 二进制和十六进制的直接映射：为什么可以四位一组

虽然理论上二进制转十六进制可以走“先转十进制再转十六进制”的路线，但实际工程中我们几乎不会这么做。因为16是2的4次方，所以每4位二进制正好对应1位十六进制。这意味着我们可以直接把二进制字符串从右往左每4位切一组，每组独立转换成十六进制字符，完全不需要经过十进制这个中间态。

def bin_to_hex_direct(s): # 补齐到4的倍数 pad = (4 - len(s) % 4) % 4 s = '0' * pad + s result = [] for i in range(0, len(s), 4): group = s[i:i+4] val = int(group, 2) result.append(HEX_CHARS[val]) return "".join(result)

这种直接映射法比走十进制中转快得多，特别是处理长二进制串时。原因很简单：少了两次完整的遍历和一次大数运算。在嵌入式开发、网络协议解析这些场景里，二进制和十六进制的直接映射是基本功。

注意：分组前一定要从左边补齐到4的倍数，否则最高位那组会少几位，导致结果错误。这个补齐操作在二进制转八进制（3位一组）时同样适用。

5. 26进制：非标准进制的特殊处理

5.1 26进制到底该怎么定义

26进制是这篇文章里最特殊的一个，因为它没有统一的国际标准。常见的定义有两种：一种是用A到Z表示0到25，另一种是用A到Z表示1到26。这两种定义会导致完全不同的转换结果，所以在动手写代码之前，必须先明确你的场景用的是哪种。

用A表示0的定义，本质上和十六进制没有区别，只是基数从16变成了26。转换逻辑完全一样，把HEX_CHARS换成26个字母就行。这种定义在Excel列号转换里比较少见，但在某些自定义编码方案里会出现。

用A表示1的定义，才是Excel列号那种场景。这种定义下，没有“零”的概念，A是1，Z是26，AA是27。这种“从1开始”的进制在数学上叫“双射进制”，转换逻辑和标准进制有微妙但关键的差异。

我当年做短链接工具时，一开始用的是A表示0的方案，结果发现生成的短码里会出现前导A，看起来很奇怪。后来改成A表示1的方案，短码更紧凑，也更符合直觉。所以选哪种定义，取决于你的具体需求。

5.2 A表示0的26进制：直接套用标准进制逻辑

先看简单的A表示0的方案：

ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" def dec_to_base26_zero(n): if n == 0: return "A" digits = [] while n > 0: digits.append(ALPHA[n % 26]) n //= 26 return "".join(reversed(digits)) def base26_zero_to_dec(s): result = 0 for ch in s.upper(): result = result * 26 + ALPHA.index(ch) return result

这套逻辑和十六进制完全一致，只是基数从16换成了26。ALPHA.index(ch)返回字符在字母表中的位置，A返回0，B返回1，以此类推。这种方案的好处是逻辑统一，容易理解和维护。

5.3 A表示1的26进制：双射进制的转换技巧

A表示1的方案就麻烦一些。因为每一位的范围是1到26，而不是0到25，所以短除法不能直接套用。我们需要在每次取余之前先减1，把1到26的范围映射到0到25：

def dec_to_base26_one(n): if n <= 0: raise ValueError("数值必须大于0") digits = [] while n > 0: n -= 1 # 关键步骤：先减1，把1-26映射到0-25 digits.append(ALPHA[n % 26]) n //= 26 return "".join(reversed(digits))

这个n -= 1是双射进制转换的核心技巧。为什么需要它？因为标准短除法假设每一位的范围是0到基数减1，而双射进制的范围是1到基数。减1操作把范围平移了，让短除法重新适用。

反向转换时，同样需要做偏移：

def base26_one_to_dec(s): result = 0 for ch in s.upper(): result = result * 26 + (ALPHA.index(ch) + 1) return result

ALPHA.index(ch) + 1把A到Z映射成1到26，然后按标准按权展开求和。这套逻辑我实测过很多次，从A到ZZ再到AAA，结果都正确。

提示：双射进制的转换在Excel列号处理、某些编号系统里非常常见。如果你发现转换结果总是差1，大概率就是忘了做这个偏移。

6. 通用进制转换框架的设计与实现

6.1 把四种进制统一到一个函数里

写到这里，二进制、十进制、十六进制、26进制的转换逻辑都清楚了。但实际项目里，你不可能为每种进制写一套独立的函数。更好的做法是设计一个通用的转换框架，把基数作为参数传进去。

DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" def to_base(n, base): if not 2 <= base <= 36: raise ValueError("基数必须在2到36之间") if n == 0: return "0" negative = n < 0 n = abs(n) digits = [] while n > 0: digits.append(DIGITS[n % base]) n //= base result = "".join(reversed(digits)) return "-" + result if negative else result def from_base(s, base): if not 2 <= base <= 36: raise ValueError("基数必须在2到36之间") s = s.upper() negative = s.startswith("-") if negative: s = s[1:] result = 0 for ch in s: if ch not in DIGITS[:base]: raise ValueError(f"字符 {ch} 不属于{base}进制") result = result * base + DIGITS.index(ch) return -result if negative else result

这个框架支持2到36进制，覆盖了二进制、八进制、十进制、十六进制和26进制。DIGITS字符串包含了0到9和A到Z共36个字符，正好够用。负数处理也加上了，实用性更强。

6.2 通用框架的性能瓶颈在哪里

通用框架虽然灵活，但性能上比专用函数差一些。主要瓶颈在DIGITS.index(ch)这个操作上。index()方法是线性查找，每次都要从头遍历字符串，时间复杂度是O(base)。在36进制下，每个字符都要比较最多36次，长字符串转换时开销很明显。

优化方法是用字典做O(1)查找：

DIGIT_MAP = {ch: i for i, ch in enumerate(DIGITS)} def from_base_fast(s, base): s = s.upper() result = 0 for ch in s: result = result * base + DIGIT_MAP[ch] return result

我实测过，在转换1000位以上的长字符串时，字典版本比index()版本快3到5倍。这个差距在批量处理场景下非常可观。

另一个优化点是to_base里的字符串拼接。用列表收集再join已经是最优解了，不要用+=直接拼字符串。Python的字符串是不可变的，每次+=都会创建新对象并复制内容，数据量大时性能会急剧下降。

6.3 什么时候该用内置函数，什么时候该手写

虽然这篇文章讲的是手写进制转换，但我必须说清楚：生产环境优先用内置函数。bin()、oct()、hex()、int(s, base)这些内置函数底层是C实现的，性能远超Python手写版本，而且经过了充分测试，边界情况处理得很完善。

手写转换的适用场景主要有三个：一是学习和面试，理解底层原理；二是内置函数覆盖不到的场景，比如26进制；三是需要深度定制转换逻辑的场景，比如自定义字符集、特殊的前导零处理、非标准的双射进制等。

我自己的原则是：能用内置就用内置，内置搞不定再手写。手写的时候，一定要写单元测试覆盖边界情况，特别是0、负数、空字符串、非法字符这些。

7. 实测中踩过的坑与边界情况处理

7.1 零值处理：为什么0总是出问题

0是进制转换里最容易出问题的值。短除法的循环条件是n > 0，如果传入0，循环一次都不执行，返回空字符串。但0的二进制表示应该是"0"，不是空字符串。所以每个转换函数都必须单独处理0。

更隐蔽的问题是双射进制里的0。在A表示1的26进制里，根本没有0这个概念，因为最小是A代表1。如果传入0，应该抛异常还是返回空字符串？我的做法是抛ValueError，因为0在这个进制体系里没有合法表示，静默返回错误结果比抛异常更危险。

还有一种情况是前导零。"0011"和"11"在数值上相等，但字符串表示不同。如果你的场景需要保留前导零（比如固定长度的编码），那转换函数就需要额外处理。标准转换函数通常会去掉前导零，这是符合数学定义的，但不一定符合业务需求。

7.2 大小写敏感：一个容易被忽略的细节

十六进制和26进制都涉及字母，大小写处理不当会导致转换失败。int("ff", 16)能正常工作，但int("FF", 16)也能正常工作，因为int()内置函数会自动处理大小写。但手写函数如果不做upper()或lower()统一，就会出现"ff"能转、"FF"报错的情况。

我的建议是在函数入口统一转大写，内部全部用大写处理。这样对外接口更宽容，用户传大写小写都能正常工作。输出的时候也统一用大写，保持一致性。

注意：有些场景对大小写敏感，比如Base64编码里大小写代表不同值。这种场景下不能做大小写转换，必须严格区分。所以统一大小写这个策略只适用于大小写不敏感的进制体系。

7.3 非法字符校验：静默错误比崩溃更可怕

前面提到过，不校验非法字符会导致静默错误。比如bin_to_dec("102")，如果代码里用int(ch)，int('2')返回2，最终结果就错了，但程序不会报错。这种bug最难排查，因为表面上一切正常，只是结果不对。

我的做法是在转换函数入口做严格校验，非法字符直接抛ValueError，并带上具体的字符和位置信息。这样调用方能在第一时间发现问题，而不是等到结果用错了才回头排查。

def validate(s, valid_chars): for i, ch in enumerate(s): if ch not in valid_chars: raise ValueError(f"位置{i}处发现非法字符: {ch}")

校验会带来一点性能开销，但相比静默错误带来的排查成本，这点开销完全值得。在性能极度敏感的场景，可以把校验做成可选项，默认开启，需要时关闭。

7.4 大数转换：Python的整数没有溢出问题，但性能有

Python的整数是任意精度的，不存在C语言里int溢出的问题。这意味着你可以转换任意大的数，比如2的1000次方。但任意精度也意味着大数运算比机器字长运算慢得多。

我实测过，转换一个1000位的十进制数到二进制，手写函数大概需要几毫秒，而内置的bin()函数只需要几十微秒。差距主要来自Python层面的循环开销和大数除法运算。

如果你的场景需要频繁转换大数，有几个优化方向：一是尽量用内置函数；二是用divmod()一次拿到商和余数，比分别做除法和取模快；三是考虑用gmpy2这类第三方库，它们对大数运算做了专门优化。

# 用divmod优化短除法 while n > 0: n, r = divmod(n, base) digits.append(DIGITS[r])

divmod()在CPython里是一个原子操作，比先n // base再n % base少一次大数运算，性能提升在10%到20%左右。这个优化在大数场景下很值得做。

8. 从进制转换延伸出的实用技巧

8.1 用进制转换做短链接ID压缩

回到我开头提到的短链接场景。自增ID是十进制的大整数，直接放在URL里又长又难看。用62进制（0-9、a-z、A-Z）压缩后，同样的数值长度能缩短一半以上。比如十进制123456789转成62进制是8m0Kx，只有5个字符，比原来的9位短了很多。

实现思路和26进制完全一样，只是把字符集从26个字母扩展到62个字符。核心代码就是前面通用框架里的to_base和from_base，把DIGITS换成62个字符的字符串就行。

这里有个经验：字符集里不要包含容易混淆的字符，比如数字0和字母O、数字1和字母l。如果短链接需要人工输入，去掉这些混淆字符能大幅降低输错率。我一般用去掉0O1l的58个字符做字符集，虽然压缩率略低一点，但用户体验好很多。

8.2 进制转换在数据校验中的应用

进制转换还有一个不太为人知的用途：数据校验。比如你可以把一段数据的哈希值转成36进制，得到一个较短的校验码。用户输入数据后，重新计算哈希并转换，对比校验码是否一致，就能判断数据是否被篡改。

这种校验方式比传统的MD5、SHA更轻量，适合对安全性要求不高的场景，比如配置文件完整性检查、缓存key校验等。当然，它不能替代加密哈希，因为进制转换本身不提供任何安全保证，只是把哈希值变短了而已。

8.3 性能对比：手写函数 vs 内置函数

最后给一组我实测的性能数据，供你参考。测试环境是普通的开发机，转换一个20位的十进制数10000次：

数据很直观：内置函数比手写快一个数量级。所以再次强调，生产环境能用内置就用内置。手写版本的价值在于理解原理和覆盖特殊场景，不是用来替代内置函数的。

但如果你的场景是26进制这种内置函数不支持的情况，那手写就是唯一选择。这时候可以放心，即使是手写版本，转换一个20位数也只需要十几微秒，完全能满足绝大多数业务需求。

提示：如果你需要频繁做同一种进制转换，可以把转换函数用functools.lru_cache做缓存。对于重复输入的转换请求，缓存能带来数量级的性能提升。这个技巧在Web服务里特别有用，因为短链接生成这类场景经常会有重复的ID转换请求。