Python中进制转换主要涉及十进制、二进制、八进制和十六进制之间的相互转换。下表概括了Python内置的进制转换函数及其用法： | 转换方向 | 核心函数 | 说明 | 示例（十进制29） | 输出 | | :--- | :--- | :--- | :--- | :--- | | **十进制 → 二进制** | `bin()` | 返回以`0b`开头的二进制字符串 | `bin(29)` | `0b11101` | | **十进制 → 八进制** | `oct()` | 返回以`0o`开头的八进制字符串 | `oct(29)` | `0o35` | | **十进制 → 十六进制** | `hex()` | 返回以`0x`开头的十六进制字符串 | `hex(29)` | `0x1d` | | **其他进制 → 十进制** | `int(x, base)` | 将字符串`x`按`base`进制转换为十进制整数 | `int("35", 8)` | `29` | ### 1. 十进制转换为其他进制 Python提供了三个内置函数直接将十进制整数转换为二进制、八进制和十六进制的字符串表示[ref_3]。 ```python # 十进制数 decimal_num = 29 # 十进制转二进制 binary_str = bin(decimal_num) # 返回字符串 '0b11101' print(f"十进制 {decimal_num} 的二进制表示: {binary_str}") # 十进制转八进制 octal_str = oct(decimal_num) # 返回字符串 '0o35' print(f"十进制 {decimal_num} 的八进制表示: {octal_str}") # 十进制转十六进制 hex_str = hex(decimal_num) # 返回字符串 '0x1d' print(f"十进制 {decimal_num} 的十六进制表示: {hex_str}") ``` **输出结果**： ``` 十进制 29 的二进制表示: 0b11101 十进制 29 的八进制表示: 0o35 十进制 29 的十六进制表示: 0x1d ``` **注意**：`bin()`、`oct()`、`hex()`返回的都是字符串类型，并且带有前缀（`0b`、`0o`、`0x`）[ref_3]。如果只需要数值部分，可以使用切片操作去掉前缀： ```python # 去掉前缀获取纯数值字符串 binary_value = bin(29)[2:] # '11101' octal_value = oct(29)[2:] # '35' hex_value = hex(29)[2:] # '1d' print(f"纯二进制值: {binary_value}") print(f"纯八进制值: {octal_value}") print(f"纯十六进制值: {hex_value}") ``` ### 2. 其他进制转换为十进制 使用`int()`函数的第二个参数`base`可以指定进制，将字符串转换为十进制整数[ref_1][ref_3]。 ```python # 二进制转十进制 binary_str = "11101" decimal_from_bin = int(binary_str, 2) # 29 print(f"二进制 {binary_str} 的十进制值: {decimal_from_bin}") # 八进制转十进制 octal_str = "35" decimal_from_oct = int(octal_str, 8) # 29 print(f"八进制 {octal_str} 的十进制值: {decimal_from_oct}") # 十六进制转十进制 hex_str = "1d" decimal_from_hex = int(hex_str, 16) # 29 print(f"十六进制 {hex_str} 的十进制值: {decimal_from_hex}") # 也可以直接使用带前缀的字符串 print(f"int('0b11101', 0) = {int('0b11101', 0)}") # 29，base=0表示自动识别前缀 print(f"int('0o35', 0) = {int('0o35', 0)}") # 29 print(f"int('0x1d', 0) = {int('0x1d', 0)}") # 29 ``` **数学原理**：这些转换基于按权展开法。例如八进制"35"转换为十进制：`3 × 8¹ + 5 × 8⁰ = 24 + 5 = 29`[ref_1]。十六进制"DF"转换为十进制：`D(13) × 16¹ + F(15) × 16⁰ = 13×16 + 15×1 = 208 + 15 = 223`[ref_1]。 ### 3. 任意进制之间的转换 通过十进制作为中间桥梁，可以实现任意两种进制之间的转换。 ```python def convert_base(num_str, from_base, to_base): """ 将字符串表示的数值从一种进制转换为另一种进制 参数: num_str: 要转换的数字字符串 from_base: 原始进制 (2, 8, 10, 16等) to_base: 目标进制 (2, 8, 10, 16等) 返回: 目标进制的字符串表示 """ # 先转换为十进制 decimal_num = int(num_str, from_base) # 再从十进制转换为目标进制 if to_base == 2: return bin(decimal_num) elif to_base == 8: return oct(decimal_num) elif to_base == 16: return hex(decimal_num) elif to_base == 10: return str(decimal_num) else: # 自定义进制转换（2-36进制） digits = "0123456789abcdefghijklmnopqrstuvwxyz" if decimal_num == 0: return "0" result = "" while decimal_num > 0: result = digits[decimal_num % to_base] + result decimal_num //= to_base return result # 示例：二进制转八进制 binary_num = "11101" octal_result = convert_base(binary_num, 2, 8) print(f"二进制 {binary_num} 转八进制: {octal_result}") # 0o35 # 示例：十六进制转二进制 hex_num = "1d" binary_result = convert_base(hex_num, 16, 2) print(f"十六进制 {hex_num} 转二进制: {binary_result}") # 0b11101 # 示例：十进制转五进制（自定义进制） decimal_num = "29" quinary_result = convert_base(decimal_num, 10, 5) print(f"十进制 {decimal_num} 转五进制: {quinary_result}") # 104 ``` ### 4. 进制转换的数学原理实现 除了使用内置函数，我们也可以手动实现进制转换算法来理解其原理。十进制转其他进制采用"除基取余法"[ref_2]，其他进制转十进制采用"按权展开法"[ref_1]。 ```python def decimal_to_base(n, base): """手动实现十进制转任意进制（2-36进制）""" if n == 0: return "0" digits = "0123456789abcdefghijklmnopqrstuvwxyz" result = "" # 处理负数 is_negative = False if n < 0: is_negative = True n = -n # 除基取余法[ref_2] while n > 0: remainder = n % base result = digits[remainder] + result n //= base if is_negative: result = "-" + result return result def base_to_decimal(num_str, base): """手动实现任意进制转十进制""" digits = "0123456789abcdefghijklmnopqrstuvwxyz" num_str = num_str.lower() # 处理负数 is_negative = False if num_str[0] == '-': is_negative = True num_str = num_str[1:] decimal_value = 0 power = 0 # 从右向左按权展开[ref_1] for digit in reversed(num_str): digit_value = digits.index(digit) decimal_value += digit_value * (base ** power) power += 1 if is_negative: decimal_value = -decimal_value return decimal_value # 测试手动实现的转换 print("=== 手动实现进制转换 ===") print(f"十进制 29 转二进制: {decimal_to_base(29, 2)}") # 11101 print(f"二进制 11101 转十进制: {base_to_decimal('11101', 2)}") # 29 print(f"十进制 29 转八进制: {decimal_to_base(29, 8)}") # 35 print(f"八进制 35 转十进制: {base_to_decimal('35', 8)}") # 29 print(f"十进制 29 转十六进制: {decimal_to_base(29, 16)}") # 1d print(f"十六进制 1d 转十进制: {base_to_decimal('1d', 16)}") # 29 ``` ### 5. 处理不同进制的数值表示 在Python中，可以直接使用不同进制的字面量表示数值[ref_3]。 ```python # 不同进制的字面量表示[ref_3] decimal_num = 29 # 十进制 binary_num = 0b11101 # 二进制（前缀0b或0B） octal_num = 0o35 # 八进制（前缀0o或0O） hex_num = 0x1d # 十六进制（前缀0x或0X） print(f"二进制字面量 0b11101 = {binary_num}") print(f"八进制字面量 0o35 = {octal_num}") print(f"十六进制字面量 0x1d = {hex_num}") # 所有字面量在内部都存储为十进制 print(f"\n验证相等性:") print(f"29 == 0b11101: {29 == 0b11101}") # True print(f"29 == 0o35: {29 == 0o35}") # True print(f"29 == 0x1d: {29 == 0x1d}") # True # 算术运算 result = 0b1010 + 0o12 + 0xa # 二进制10 + 八进制10 + 十六进制10 print(f"\n混合进制运算: 0b1010 + 0o12 + 0xa = {result}") # 30 ``` ### 6. 格式化输出进制表示 使用字符串格式化可以控制进制输出的格式。 ```python # 使用format()函数格式化进制输出 num = 29 # 二进制输出 print(f"二进制: {num:#b}") # 0b11101（带前缀） print(f"二进制: {num:b}") # 11101（不带前缀） # 八进制输出 print(f"八进制: {num:#o}") # 0o35（带前缀） print(f"八进制: {num:o}") # 35（不带前缀） # 十六进制输出 print(f"十六进制: {num:#x}") # 0x1d（小写带前缀） print(f"十六进制: {num:#X}") # 0X1D（大写带前缀） print(f"十六进制: {num:x}") # 1d（小写不带前缀） print(f"十六进制: {num:X}") # 1D（大写不带前缀） # 指定宽度和对齐 print(f"\n格式化输出:") print(f"二进制(宽度10,右对齐): {num:>10b}") # ' 11101' print(f"八进制(宽度10,居中): {num:^10o}") # ' 35 ' print(f"十六进制(宽度10,填充0): {num:010X}") # '000000001D' ``` ### 7. 实际应用示例 #### 7.1 颜色值转换（RGB十六进制表示） ```python def rgb_to_hex(r, g, b): """将RGB值转换为十六进制颜色代码""" return f"#{r:02x}{g:02x}{b:02x}" def hex_to_rgb(hex_color): """将十六进制颜色代码转换为RGB值""" hex_color = hex_color.lstrip('#') r = int(hex_color[0:2], 16) g = int(hex_color[2:4], 16) b = int(hex_color[4:6], 16) return r, g, b # 示例 rgb = (255, 0, 128) hex_color = rgb_to_hex(*rgb) print(f"RGB{rgb} 的十六进制表示: {hex_color}") # #ff0080 rgb_back = hex_to_rgb(hex_color) print(f"十六进制{hex_color} 的RGB值: {rgb_back}") # (255, 0, 128) ``` #### 7.2 权限管理（Linux文件权限） ```python def permission_to_octal(perm_str): """将rwx权限字符串转换为八进制表示""" if len(perm_str) != 9: raise ValueError("权限字符串必须是9个字符") perm_dict = {'r': 4, 'w': 2, 'x': 1, '-': 0} # 每3位一组转换为八进制 octal_perms = [] for i in range(0, 9, 3): group = perm_str[i:i+3] value = sum(perm_dict[ch] for ch in group) octal_perms.append(str(value)) return ''.join(octal_perms) def octal_to_permission(octal_str): """将八进制权限表示转换为rwx字符串""" if len(octal_str) != 3: raise ValueError("八进制权限必须是3位数字") perm_dict = {4: 'r', 2: 'w', 1: 'x', 0: '-'} result = [] for digit in octal_str: num = int(digit) # 二进制位判断 for value, char in [(4, 'r'), (2, 'w'), (1, 'x')]: result.append(char if num & value else '-') return ''.join(result) # 示例 perm_str = "rwxr-xr--" octal_perm = permission_to_octal(perm_str) print(f"权限字符串 '{perm_str}' 的八进制表示: {octal_perm}") # 754 back_to_str = octal_to_permission(octal_perm) print(f"八进制 {octal_perm} 的权限字符串: {back_to_str}") # rwxr-xr-- ``` #### 7.3 IP地址与整数的转换 ```python def ip_to_int(ip_address): """将点分十进制IP地址转换为32位整数""" parts = ip_address.split('.') if len(parts) != 4: raise ValueError("IP地址必须是4个部分") result = 0 for part in parts: result = (result << 8) | int(part) return result def int_to_ip(num): """将32位整数转换为点分十进制IP地址""" parts = [] for _ in range(4): parts.insert(0, str(num & 255)) num >>= 8 return '.'.join(parts) # 示例 ip = "192.168.1.1" ip_int = ip_to_int(ip) print(f"IP地址 {ip} 的整数表示: {ip_int}") print(f"整数 {ip_int} 的二进制: {bin(ip_int)}") print(f"整数 {ip_int} 的十六进制: {hex(ip_int)}") ip_back = int_to_ip(ip_int) print(f"转换回IP地址: {ip_back}") ``` ### 8. 性能比较与最佳实践 ```python import timeit def performance_comparison(): """比较不同进制转换方法的性能""" num = 123456789 # 测试各种转换方法 def test_bin(): return bin(num) def test_oct(): return oct(num) def test_hex(): return hex(num) def test_int_from_bin(): return int(bin(num)[2:], 2) def test_int_from_oct(): return int(oct(num)[2:], 8) def test_int_from_hex(): return int(hex(num)[2:], 16) # 性能测试 tests = [ ("bin()", test_bin), ("oct()", test_oct), ("hex()", test_hex), ("int(bin)", test_int_from_bin), ("int(oct)", test_int_from_oct), ("int(hex)", test_int_from_hex), ] print("性能比较（执行100000次）:") for name, func in tests: time_taken = timeit.timeit(func, number=100000) print(f"{name:15} {time_taken:.6f}秒") performance_comparison() ``` **最佳实践总结**： 1. **内置函数优先**：Python的`bin()`、`oct()`、`hex()`和`int()`函数经过高度优化，性能最好[ref_3]。 2. **注意前缀处理**：`bin()`、`oct()`、`hex()`返回带前缀的字符串，`int()`可以自动识别前缀[ref_1][ref_3]。 3. **异常处理**：进行进制转换时应处理可能的异常，如无效字符或超出进制范围。 4. **大数处理**：Python内置支持大整数，可以处理任意大小的数值。 ```python def safe_base_conversion(num_str, from_base, to_base): """安全的进制转换函数，包含错误处理""" try: # 转换为十进制 decimal_val = int