Python脚本-base_converter改进

2025-01-13

之前的进制转换改进，增加了bin2bin和hex2hex，以及大小端模式。

#!/usr/bin/python3.6
# -*- coding: utf-8 -*-
# Author: ZLin
# Date: 2025-01-02
# Description: This script converts binary to hexadecimal, hexadecimal to binary, binary to binary, or hexadecimal to hexadecimal.
# It also supports odd or even parity and byte order (little-endian or big-endian).
# The output will be reversed if big-endian is selected, but the parity bit stays at the leftmost side.
# Usage:
# python script.py -i input.txt -o output.txt -m bin2hex -e big -p even
# -i: Input file path
# -o: Output file path
# -m: Mode (bin2hex, hex2bin, bin2bin, hex2hex)
# -e: Endian (little or big)
# -p: Parity (odd, even, or none)
# -v: Verbose output (optional)

import argparse
import re

class BaseConverter:
  def __init__(self, input_file, output_file, mode, start_line, parity, endian, verbose):
    # Added validation for invalid parity and endian parameters
    if parity not in ["odd", "even", "none"]:
      raise ValueError(f"Invalid parity value: {parity}. Supported values are 'odd', 'even', or 'none'.")
    if endian not in ["little", "big"]:
      raise ValueError(f"Invalid endian value: {endian}. Supported values are 'little' or 'big'.")
    
    self.input_file = input_file
    self.output_file = output_file
    self.mode = mode
    self.start_line = start_line
    self.parity = parity
    self.endian = endian
    self.verbose = verbose  # Store verbose flag

  def convert(self):
    try:
      # Open the file with UTF-8 encoding to support non-ASCII characters
      with open(self.input_file, 'r', encoding='utf-8') as infile, open(self.output_file, 'w', encoding='utf-8') as outfile:
        # Write the lines before the start line as is
        for current_line_num, line in enumerate(infile, start=1):
          # Write lines before the start line without modification
          if current_line_num < self.start_line:
            outfile.write(line)
            continue

          # Process the lines starting from the specified start line
          line = line.strip()
          if not line:  # Skip empty lines
            continue

          # Extract and preserve the suffix (such as commas, semicolons, etc.)
          original_line, suffix = self.extract_suffix(line)

          # Convert based on the selected mode
          if self.mode == "bin2hex":
            result = self.binary_to_hex(original_line)
          elif self.mode == "hex2bin":
            result = self.hex_to_binary(original_line)
          elif self.mode == "bin2bin":
            result = original_line  # Direct output for binary-to-binary
          elif self.mode == "hex2hex":
            result = original_line  # Direct output for hex-to-hex
          else:
            if self.verbose:
              print("Unsupported mode!")
            return

          if self.verbose:
            print(f"Converted result (before endian handling): {result}")

          # Reverse the byte order (if big-endian mode is selected)
          if self.endian == "big":
            result = self.reverse_endian(result)

          if self.verbose:
            print(f"Converted result (after endian handling): {result}")

          # Add the parity bit if required
          if self.parity != "none":
            result = self.add_parity_bit(result)

          # Concatenate the result with the suffix and write to the output file
          result_with_suffix = result + suffix
          outfile.write(result_with_suffix + '\n')

        if self.verbose:
          print(f"Conversion completed. The result is saved in {self.output_file}")

    except FileNotFoundError as e:
      if self.verbose:
        print(f"File not found: {e}")
    except IOError as e:
      if self.verbose:
        print(f"IO error occurred: {e}")
    except Exception as e:
      if self.verbose:
        print(f"An unexpected error occurred: {e}")

  def binary_to_hex(self, binary_str):
    """Convert binary string to hexadecimal string"""
    binary_str = binary_str.replace(' ', '')  # Remove spaces
    if not all(c in '01' for c in binary_str):  # Ensure the string is binary
      raise ValueError(f"Invalid binary string '{binary_str}'")
    hex_str = hex(int(binary_str, 2))[2:].upper()  # Convert to uppercase hexadecimal
    return hex_str

  def hex_to_binary(self, hex_str):
    """Convert hexadecimal string to binary string"""
    hex_str = hex_str.replace(' ', '')  # Remove spaces
    if not all(c in '0123456789ABCDEFabcdef' for c in hex_str):  # Ensure the string is hexadecimal
      raise ValueError(f"Invalid hexadecimal string '{hex_str}'")
    bin_str = bin(int(hex_str, 16))[2:].zfill(len(hex_str) * 4)  # Convert to binary and pad to correct length
    return bin_str

  def add_parity_bit(self, data):
    """Add a parity bit (odd or even) to the left of the data"""
    ones_count = data.count('1')
    if self.parity == "odd":
      parity_bit = '1' if ones_count % 2 == 0 else '0'  # If even number of 1's, the parity bit is 1, else 0
    elif self.parity == "even":
      parity_bit = '0' if ones_count % 2 == 0 else '1'  # If even number of 1's, the parity bit is 0, else 1
    return parity_bit + data

  def reverse_endian(self, data):
    """Reverse the byte order (little-endian to big-endian or vice versa)"""
    # Reverse the data byte-wise
    reversed_data = ''.join(reversed([data[i:i + 8] for i in range(0, len(data), 8)]))
    return reversed_data

  def extract_suffix(self, line):
    """Extract the suffix (such as commas, semicolons, etc.) from the line"""
    match = re.search(r'([,;.!?])$', line)
    if match:
      return line[:-len(match.group(1))], match.group(1)
    return line, ''  # If there is no suffix, return the original line

def parse_arguments():
  parser = argparse.ArgumentParser(description="Perform base conversion: binary to hexadecimal, hexadecimal to binary, binary to binary, or hexadecimal to hexadecimal. Supports odd or even parity and byte order (little-endian or big-endian).")
  parser.add_argument("-i", "--input", type=str, required=True, help="Input file path")
  parser.add_argument("-o", "--output", type=str, required=True, help="Output file path")
  parser.add_argument("-m", "--mode", type=str, choices=["bin2hex", "hex2bin", "bin2bin", "hex2hex"], required=True, help="Conversion mode: bin2hex, hex2bin, bin2bin, or hex2hex")
  parser.add_argument("-s", "--start-line", type=int, default=1, help="Start conversion from the specified line number, default is line 1")
  parser.add_argument("-p", "--parity", type=str, choices=["odd", "even", "none"], default="none", help="Enable odd or even parity. Default is 'none', use 'odd' or 'even' to enable")
  parser.add_argument("-e", "--endian", type=str, choices=["little", "big"], default="little", help="Byte order (little-endian or big-endian). Default is 'little'")
  parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose output (default is off)")
  return parser.parse_args()

if __name__ == "__main__":
  args = parse_arguments()
  converter = BaseConverter(args.input, args.output, args.mode, args.start_line, args.parity, args.endian, args.verbose)
  converter.convert()

主要修改的部分及解释：

增加了 bin2bin 和 hex2hex 模式：
- bin2bin：此模式下，程序会直接将输入的二进制字符串输出为二进制字符串，不做任何转换。
- hex2hex：此模式下，程序会直接将输入的十六进制字符串输出为十六进制字符串，同样不做任何转换。
增加了 endian 参数：
- endian 参数指定字节顺序，默认为“小端”(little)，如果设置为“大端”(big)，会对输出数据进行字节顺序翻转。

本文作者： ICXNM-ZLin
本文链接： https://talent-tudou.github.io/2025/01/13/Programming/Python脚本-base_converter改进/
版权声明： 本作品采用 CC BY-NC-SA 4.0 进行许可。转载请注明出处！