Python中二进制、八进制与十六进制高级操作指南

# 不同进制的字面量表示
bin_val = 0b1101     # 二进制
oct_val = 0o755       # 八进制
hex_val = 0xFA2C      # 十六进制

# 进制转换函数
num = 42
print(f"二进制: {bin(num)}")      # 0b101010
print(f"八进制: {oct(num)}")      # 0o52
print(f"十六进制: {hex(num)}")     # 0x2a

# 字符串转换
print(int('101010', 2))   # 42
print(int('52', 8))       # 42
print(int('2a', 16))      # 42

# f-string格式化
value = 2024
print(f"二进制: {value:#b}")    # 0b11111101000
print(f"八进制: {value:#o}")    # 0o3750
print(f"十六进制: {value:#x}")  # 0x7e8

# 移除前缀
print(f"{value:b}")  # 11111101000
print(f"{value:o}")  # 3750
print(f"{value:x}")  # 7e8

# 填充对齐
print(f"{value:0>16b}")  # 0000011111101000

# 位掩码技术
def bit_mask_example():
    """位掩码应用示例"""
    # 原始数据
    status_reg = 0x8F  # 二进制: 10001111
    
    # 位掩码定义
    ERROR_MASK   = 0b10000000
    WARNING_MASK = 0b01000000
    DATA_READY   = 0b00000001
    
    # 检查特定位
    has_error = (status_reg & ERROR_MASK) != 0
    print(f"Error flag: {has_error}")  # True
    
    # 设置特定位
    status_reg |= DATA_READY
    print(f"Status after set: {bin(status_reg)}")  # 0b10001111 -> 0b10001111
    
    # 清除特定位
    status_reg &= ~WARNING_MASK
    print(f"Status after clear: {bin(status_reg)}")  # 0b10001111 -> 0b10001111

bit_mask_example()

# 创建bytes对象
raw_data = bytes([0x48, 0x65, 0x6C, 0x6C, 0x6F])  # ASCII: H e l l o
print(f"原始字节: {raw_data}")  # b'Hello'

# 十六进制表示与转换
hex_str = '48656c6c6f'
data = bytes.fromhex(hex_str)
print(f"解码数据: {data.decode()}")  # Hello

# 字节序列操作
header = data[:2]
payload = data[2:]
print(f"Header: {header.hex()}")  # 4865

import struct

def parse_ethernet_frame(data):
    """解析以太网帧"""
    # 解包14字节帧头 (6字节目标MAC, 6字节源MAC, 2字节类型)
    dest_mac, src_mac, eth_type = struct.unpack('!6s6sH', data[:14])
    
    # 格式化MAC地址
    def format_mac(mac_bytes):
        return ':'.join(f'{b:02x}' for b in mac_bytes)
    
    return {
        'destination': format_mac(dest_mac),
        'source': format_mac(src_mac),
        'type': f'0x{eth_type:04x}'
    }

# 测试数据: 目标MAC 00:11:22:33:44:55, 源MAC AA:BB:CC:DD:EE:FF, 类型0x0800
frame = bytes.fromhex('001122334455aabbccddeeff0800')
print(parse_ethernet_frame(frame))
# 输出: {'destination': '00:11:22:33:44:55', 'source': 'aa:bb:cc:dd:ee:ff', 'type': '0x0800'}

class GPIO_CTRL:
    """GPIO控制器寄存器"""
    # 寄存器偏移量
    BASE_ADDR = 0x40020000
    
    def __init__(self):
        # 寄存器地址定义
        self.MODER = BASE_ADDR + 0x00   # 模式寄存器
        self.OTYPER = BASE_ADDR + 0x04  # 输出类型寄存器
        self.OSPEEDR = BASE_ADDR + 0x08 # 输出速度寄存器
        
        # 位域定义
        self.PIN0 = 0
        self.PIN1 = 2
        self.PIN2 = 4
        
        # 模式配置
        self.INPUT = 0b00
        self.OUTPUT = 0b01
        self.ALT_FUNC = 0b10
        self.ANALOG = 0b11

def configure_gpio():
    """配置GPIO模拟实现"""
    # 模拟寄存器
    registers = {
        GPIO_CTRL.MODER: 0x00000000,
        GPIO_CTRL.OTYPER: 0x00000000,
        GPIO_CTRL.OSPEEDR: 0x00000000
    }
    
    # 设置PIN2为输出模式
    moder_value = registers[GPIO_CTRL.MODER]
    moder_value |= GPIO_CTRL.OUTPUT << GPIO_CTRL.PIN2
    registers[GPIO_CTRL.MODER] = moder_value
    
    # 设置PIN1为高速模式
    ospeedr_value = registers[GPIO_CTRL.OSPEEDR]
    ospeedr_value |= 0b11 << GPIO_CTRL.PIN1  # 高速模式值11
    registers[GPIO_CTRL.OSPEEDR] = ospeedr_value
    
    # 打印寄存器状态
    print(f"MODER:  0x{registers[GPIO_CTRL.MODER]:08X}")
    print(f"OSPEEDR: 0x{registers[GPIO_CTRL.OSPEEDR]:08X}")

configure_gpio()

import base64

def custom_base64(data):
    """Base64编码实现"""
    # Base64字符表
    base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
    
    # 二进制填充处理
    binary_str = ''.join(f"{byte:08b}" for byte in data)
    padded_length = (len(binary_str) + 5) // 6 * 6
    binary_str = binary_str.ljust(padded_length, '0')
    
    # 按6位分组转换
    result = ''
    for i in range(0, len(binary_str), 6):
        index = int(binary_str[i:i+6], 2)
        result += base64_chars[index]
    
    # 添加填充字符
    padding = (4 - len(result) % 4) % 4
    return result + '=' * padding

# 测试比较
original = b'Hello'
custom = custom_base64(original)
builtin = base64.b64encode(original).decode()

print(f"Custom: {custom}")  # SGVsbG8=
print(f"Builtin: {builtin}")  # SGVsbG8=

def crc16(data: bytes, poly=0x1021, init_val=0xFFFF):
    """CRC-16/CCITT算法实现"""
    crc = init_val
    for byte in data:
        crc ^= byte << 8
        for _ in range(8):
            if crc & 0x8000:
                crc = (crc << 1) ^ poly
            else:
                crc = crc << 1
            crc &= 0xFFFF  # 保持16位
    return crc

# 测试数据
test_data = b'123456789'
result = crc16(test_data)
print(f"CRC16 for '123456789': 0x{result:04X}")  # 0x31C3

def parse_bmp_header(header):
    """解析BMP文件头"""
    # 解包文件头（14字节）
    signature, file_size, _, offset = struct.unpack('<2sI4xI', header[:14])
    
    # 检查文件类型
    if signature != b'BM':
        raise ValueError("Invalid BMP signature")
    
    # 解包信息头（40字节）
    info_header = header[14:54]
    width, height, _, depth, comp, img_size, *_ = struct.unpack('<IIIIIIII', info_header)
    
    return {
        'file_type': signature.decode(),
        'file_size': file_size,
        'data_offset': offset,
        'width': width,
        'height': height,
        'bit_depth': depth,
        'compression': comp,
        'image_size': img_size
    }

# 测试头数据 (简化的56字节头)
bmp_header = (
    b'BM' +                 # 签名
    int.to_bytes(1024, 4, 'little') +  # 文件大小
    b'\x00\x00\x00\x00' +   # 保留
    int.to_bytes(54, 4, 'little') +    # 数据偏移
    int.to_bytes(40, 4, 'little') +    # 信息头大小
    int.to_bytes(32, 4, 'little') +    # 宽度
    int.to_bytes(32, 4, 'little') +    # 高度
    int.to_bytes(1, 2, 'little') +      # 平面
    int.to_bytes(24, 2, 'little') +   # 位深
    b'\x00\x00\x00\x00' +   # 压缩方法
    b'\x00\x00\x00\x00'*3   # 其他字段
)

print(parse_bmp_header(bmp_header))

import timeit

def traditional_operations():
    # 算术方式处理二进制
    result = []
    for i in range(16):
        div = i // 4
        mod = i % 4
        if mod == 0:
            result.append(div)
    return result

def bitwise_operations():
    # 位运算处理
    return [i >> 2 for i in range(16) if (i & 0b11) == 0]

# 性能测试
trad_time = timeit.timeit(traditional_operations, number=100000)
bit_time = timeit.timeit(bitwise_operations, number=100000)

print(f"传统方法: {trad_time:.5f}秒")
print(f"位运算方法: {bit_time:.5f}秒")
print(f"性能提升: {(trad_time/bit_time - 1) * 100:.1f}%")

# 位反转预计算表 (256项)
bit_reverse_table = [
    sum(((byte >> i) & 1) << (7-i) for i in range(8))
    for byte in range(256)
]

def reverse_bits(byte):
    """使用查找表进行位反转"""
    return bit_reverse_table[byte]

# 测试
print(f"{0b11001010:08b} -> {reverse_bits(0b11001010):08b}")  # 11001010 -> 01010011

class NetworkConstants:
    """网络协议常量"""
    # 使用十六进制定义标志位
    TCP_FLAG_FIN = 0x01
    TCP_FLAG_SYN = 0x02
    TCP_FLAG_RST = 0x04
    TCP_FLAG_PSH = 0x08
    TCP_FLAG_ACK = 0x10
    TCP_FLAG_URG = 0x20

    # 定义常见端口 (十进制)
    HTTP_PORT = 80
    HTTPS_PORT = 443
    DNS_PORT = 53

def check_packet(packet):
    """使用常量的示例"""
    if packet['flags'] & NetworkConstants.TCP_FLAG_SYN:
        print("SYN packet detected")

def safe_bit_extract(value, start_bit, num_bits):
    """安全的位域提取"""
    # 创建掩码
    mask = (1 << num_bits) - 1
    
    # 移动和屏蔽
    return (value >> start_bit) & mask

# 测试边界
try:
    # 尝试提取超过32位的位置
    result = safe_bit_extract(0x12345678, 30, 5)
    print(f"结果: {result} (二进制: {bin(result)})")
except ValueError as e:
    print(e)

# 不良实践
reg |= 0x4A

# 良好实践
STATUS_ENABLE = 0x4A  # 启用状态位(01001010)
reg |= STATUS_ENABLE

# 使用struct处理大小端问题
# 小端序 (Intel处理器)
little_endian = struct.pack('<I', 0x12345678) 
# 大端序 (网络字节序)
big_endian = struct.pack('>I', 0x12345678)

# 检查数据类型
def process_binary(data):
    if not isinstance(data, (bytes, bytearray)):
        raise TypeError("仅支持字节类型")
    # ...

# 使用pydoc生成文档
class BitUtils:
    """位操作工具类"""
    def extract_bits(value, start, length):
        """安全提取位域"""
        # ...

# 添加doctest
def test_extract_bits():
    """
    >>> BitUtils.extract_bits(0b101010, 1, 3)
    5
    """
    pass