# 編碼：十進制轉(zhuǎn)十六進制
decimal_number = 255
hex_string = hex(decimal_number)
print(f"十進制 {decimal_number} 的十六進制表示: {hex_string}")
# 輸出: 十進制 255 的十六進制表示: 0xff

# 解碼：十六進制轉(zhuǎn)十進制
hex_value = '0xff'
decimal_result = int(hex_value, 16)
print(f"十六進制 {hex_value} 的十進制值: {decimal_result}")
# 輸出: 十六進制 0xff 的十進制值: 255

# 編碼為十六進制（小寫）
number = 255
hex_lower = format(number, 'x')
print(f"小寫十六進制: {hex_lower}")  # 輸出: ff

# 編碼為十六進制（大寫）
hex_upper = format(number, 'X')
print(f"大寫十六進制: {hex_upper}")  # 輸出: FF

# 使用f-strings（Python 3.6+）
print(f"f-string十六進制: {number:x}")  # 輸出: ff

import binascii

# 將字節(jié)數(shù)據(jù)編碼為十六進制
byte_data = b'Hello, World!'
hex_encoded = binascii.hexlify(byte_data)
print(f"字節(jié)數(shù)據(jù): {byte_data}")
print(f"十六進制編碼: {hex_encoded}")
print(f"解碼為字符串: {hex_encoded.decode('ascii')}")

# 輸出:
# 字節(jié)數(shù)據(jù): b'Hello, World!'
# 十六進制編碼: b'48656c6c6f2c20576f726c6421'
# 解碼為字符串: 48656c6c6f2c20576f726c6421

import binascii

# 將十六進制字符串解碼為字節(jié)數(shù)據(jù)
hex_string = '48656c6c6f2c20576f726c6421'
byte_data = binascii.unhexlify(hex_string)
print(f"十六進制字符串: {hex_string}")
print(f"解碼后的字節(jié)數(shù)據(jù): {byte_data}")
print(f"解碼為文本: {byte_data.decode('utf-8')}")

# 輸出:
# 十六進制字符串: 48656c6c6f2c20576f726c6421
# 解碼后的字節(jié)數(shù)據(jù): b'Hello, World!'
# 解碼為文本: Hello, World!

import base64

# 使用base64進行十六進制編碼
byte_data = b'Hello, World!'
hex_encoded = base64.b16encode(byte_data)
print(f"Base16編碼: {hex_encoded}")
print(f"解碼為字符串: {hex_encoded.decode('ascii')}")

# 使用base64進行十六進制解碼
hex_string = '48656C6C6F2C20576F726C6421'
byte_data = base64.b16decode(hex_string)
print(f"Base16解碼: {byte_data}")
print(f"解碼為文本: {byte_data.decode('utf-8')}")

# 輸出:
# Base16編碼: b'48656C6C6F2C20576F726C6421'
# 解碼為字符串: 48656C6C6F2C20576F726C6421
# Base16解碼: b'Hello, World!'
# 解碼為文本: Hello, World!

def hex_stream_processor(hex_stream, chunk_size=1024):
    """流式處理大型十六進制數(shù)據(jù)"""
    for i in range(0, len(hex_stream), chunk_size * 2):  # ×2因為每個字節(jié)用兩個十六進制字符表示
        chunk = hex_stream[i:i + chunk_size * 2]
        yield binascii.unhexlify(chunk)

# 使用示例
large_hex_data = '48656c6c6f2c20576f726c6421' * 1000  # 模擬大數(shù)據(jù)

for byte_chunk in hex_stream_processor(large_hex_data, 1024):
    # 處理每個字節(jié)塊
    process_data(byte_chunk)  # 假設(shè)的數(shù)據(jù)處理函數(shù)

class CustomHexCodec:
    def __init__(self, separator='', uppercase=False):
        self.separator = separator
        self.uppercase = uppercase
    
    def encode(self, byte_data):
        hex_str = binascii.hexlify(byte_data).decode('ascii')
        if self.uppercase:
            hex_str = hex_str.upper()
        
        if self.separator:
            # 添加分隔符（每兩個字符一組）
            hex_str = self.separator.join(
                hex_str[i:i+2] for i in range(0, len(hex_str), 2)
            )
        
        return hex_str
    
    def decode(self, hex_string):
        # 移除可能的分隔符
        if self.separator:
            hex_string = hex_string.replace(self.separator, '')
        
        return binascii.unhexlify(hex_string)

# 使用示例
codec = CustomHexCodec(separator=':', uppercase=True)
byte_data = b'Hello'
encoded = codec.encode(byte_data)
print(f"自定義編碼: {encoded}")  # 輸出: 48:45:4C:4C:4F

decoded = codec.decode(encoded)
print(f"解碼結(jié)果: {decoded}")  # 輸出: b'Hello'

import re

def is_valid_hex(hex_string):
    """驗證字符串是否為有效的十六進制表示"""
    # 移除可能的前綴和分隔符
    clean_hex = hex_string.lower().replace('0x', '').replace(':', '').replace(' ', '')
    
    # 檢查是否只包含十六進制字符且長度為偶數(shù)
    if re.fullmatch(r'[0-9a-f]+', clean_hex):
        return len(clean_hex) % 2 == 0
    return False

# 使用示例
test_strings = ['48656c6c6f', '0x48656c6c6f', '48:65:6c:6c:6f', 'invalid']
for test in test_strings:
    print(f"'{test}' 是有效的十六進制: {is_valid_hex(test)}")

def safe_hex_encode(byte_data):
    """安全的十六進制編碼函數(shù)"""
    try:
        return binascii.hexlify(byte_data).decode('ascii')
    except (TypeError, binascii.Error) as e:
        print(f"編碼錯誤: {e}")
        return None

def safe_hex_decode(hex_string):
    """安全的十六進制解碼函數(shù)"""
    try:
        # 清理輸入字符串
        clean_hex = hex_string.lower().replace('0x', '').replace(':', '').replace(' ', '')
        
        # 驗證長度是否為偶數(shù)
        if len(clean_hex) % 2 != 0:
            clean_hex = '0' + clean_hex  # 前導(dǎo)零填充
        
        return binascii.unhexlify(clean_hex)
    except (TypeError, binascii.Error, ValueError) as e:
        print(f"解碼錯誤: {e}")
        return None

# 使用示例
result = safe_hex_decode('48656c6c6f')  # 有效輸入
print(f"解碼結(jié)果: {result}")

result = safe_hex_decode('48656c6c6')  # 奇數(shù)長度，會自動修復(fù)
print(f"解碼結(jié)果: {result}")

result = safe_hex_decode('invalid')  # 無效輸入
print(f"解碼結(jié)果: {result}")

import timeit

# 性能測試數(shù)據(jù)
test_data = b'x' * 1000  # 1KB數(shù)據(jù)

# 測試不同編碼方法的性能
binascii_time = timeit.timeit(
    lambda: binascii.hexlify(test_data),
    number=1000
)

base64_time = timeit.timeit(
    lambda: base64.b16encode(test_data),
    number=1000
)

format_time = timeit.timeit(
    lambda: ''.join(format(byte, '02x') for byte in test_data),
    number=100
)  # 次數(shù)減少，因為這種方法較慢

print(f"binascii.hexlify: {binascii_time:.4f} 秒")
print(f"base64.b16encode: {base64_time:.4f} 秒")
print(f"format方法: {format_time:.4f} 秒")

def batch_hex_encode(byte_data, batch_size=1024):
    """批量處理十六進制編碼"""
    result = []
    for i in range(0, len(byte_data), batch_size):
        batch = byte_data[i:i + batch_size]
        result.append(binascii.hexlify(batch).decode('ascii'))
    return ''.join(result)

def batch_hex_decode(hex_string, batch_size=2048):  # ×2因為每個字節(jié)用兩個十六進制字符表示
    """批量處理十六進制解碼"""
    result = bytearray()
    for i in range(0, len(hex_string), batch_size * 2):
        batch = hex_string[i:i + batch_size * 2]
        result.extend(binascii.unhexlify(batch))
    return bytes(result)

# 使用示例
large_data = b'x' * 10000  # 10KB數(shù)據(jù)
encoded = batch_hex_encode(large_data)
decoded = batch_hex_decode(encoded)

print(f"原始數(shù)據(jù)長度: {len(large_data)}")
print(f"編碼后長度: {len(encoded)}")
print(f"解碼后長度: {len(decoded)}")
print(f"數(shù)據(jù)一致性: {large_data == decoded}")

def parse_network_packet(hex_packet):
    """解析網(wǎng)絡(luò)數(shù)據(jù)包（十六進制格式）"""
    # 移除可能的分隔符和前綴
    clean_hex = hex_packet.replace(':', '').replace(' ', '').lower()
    
    # 將十六進制字符串轉(zhuǎn)換為字節(jié)數(shù)據(jù)
    packet_data = binascii.unhexlify(clean_hex)
    
    # 解析數(shù)據(jù)包（示例：假設(shè)簡單協(xié)議）
    protocol_version = packet_data[0] >> 4
    header_length = packet_data[0] & 0x0F
    source_address = packet_data[1:5]
    destination_address = packet_data[5:9]
    payload = packet_data[9:]
    
    return {
        'protocol_version': protocol_version,
        'header_length': header_length,
        'source_address': '.'.join(str(b) for b in source_address),
        'destination_address': '.'.join(str(b) for b in destination_address),
        'payload': payload
    }

# 使用示例
hex_packet = '450000284a40000040061c2ec0a80001c0a80002'
packet_info = parse_network_packet(hex_packet)
for key, value in packet_info.items():
    print(f"{key}: {value}")

import hashlib

def calculate_hashes(data):
    """計算數(shù)據(jù)的多種哈希值（十六進制格式）"""
    if isinstance(data, str):
        data = data.encode('utf-8')
    
    hashes = {}
    algorithms = ['md5', 'sha1', 'sha256', 'sha512']
    
    for algo in algorithms:
        hash_obj = hashlib.new(algo)
        hash_obj.update(data)
        hashes[algo] = hash_obj.hexdigest()
    
    return hashes

# 使用示例
data = 'Hello, World!'
hashes = calculate_hashes(data)
for algorithm, hex_hash in hashes.items():
    print(f"{algorithm}: {hex_hash}")