Python脚本-base_converter

2025-01-02

这个脚本是一个进制转换工具，可以将二进制转成十六进制，或者将十六进制转成二进制。除了基本的进制转换功能，还可以根据需求加入奇偶校验位，并且能够处理从文件中的指定行开始进行转换，保留文件中的行尾符号（如逗号、分号等）。

Source Code

#!/usr/bin/python3.6
# -*- coding: utf-8 -*-
# Author: ZLin
# Date: 2025-01-02
# Description: This script converts binary to hexadecimal or hexadecimal to binary based on the specified mode.
# It also supports odd or even parity and preserves line-end symbols in the output file.
# All print messages are controlled by the verbose flag.

import argparse
import re

class BaseConverter:
  def __init__(self, input_file, output_file, mode, start_line, parity, verbose):
    self.input_file = input_file
    self.output_file = output_file
    self.mode = mode
    self.start_line = start_line
    self.parity = parity
    self.verbose = verbose  # Store verbose flag

  def convert(self):
    try:
      with open(self.input_file, 'r') as infile, open(self.output_file, 'w') 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)

          if self.mode == "bin2hex":
            result = self.binary_to_hex(original_line)
          elif self.mode == "hex2bin":
            result = self.hex_to_binary(original_line)
          else:
            if self.verbose:
              print("Unsupported mode!")
            return

          if self.verbose:
            print(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 Exception as e:
      if self.verbose:
        print(f"An error occurred: {e}")

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

  def hex_to_binary(self, hex_str):
    """Convert hexadecimal string to binary string"""
    hex_str = hex_str.replace(' ', '')  # Remove spaces
    if all(c in '0123456789ABCDEFabcdef' for c in hex_str):  # Ensure the string is hexadecimal
      bin_str = bin(int(hex_str, 16))[2:].zfill(len(hex_str) * 4)  # Convert to binary and pad to correct length
      return bin_str
    else:
      return f"Error: Invalid hexadecimal string '{hex_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 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 or hexadecimal to binary. Supports odd or even parity and skipping initial lines.")
  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"], required=True, help="Conversion mode: bin2hex or hex2bin")
  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("-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.verbose)
  converter.convert()

脚本总体描述：

这个脚本是一个进制转换工具，可以将二进制转成十六进制，或者将十六进制转成二进制。除了基本的进制转换功能，还可以根据需求加入奇偶校验位，并且能够处理从文件中的指定行开始进行转换，保留文件中的行尾符号（如逗号、分号等）。

脚本功能：

进制转换：
- bin2hex: 将二进制字符串转换为十六进制字符串。
- hex2bin: 将十六进制字符串转换为二进制字符串。
奇偶校验：
- 奇校验（odd）：若数据中的1的个数是偶数，则在数据的左边添加1，使得1的个数变成奇数；若数据中的1的个数已经是奇数，则在数据的左边添加0。
- 偶校验（even）：若数据中的1的个数是偶数，则在数据的左边添加0，使得1的个数保持偶数；若数据中的1的个数是奇数，则在数据的左边添加1。
从指定行开始处理：支持通过命令行参数指定从输入文件的第几行开始进行进制转换，默认从第1行开始。
保留行尾符号：转换后的内容保留原文件中的行尾符号（如逗号、分号、句号等）。
控制输出信息：所有的输出信息（print）都可以通过 verbose 参数控制。默认情况下，脚本不输出任何信息，只有在启用了 verbose 参数后才会显示详细的转换过程信息。

脚本结构：

BaseConverter 类：
- 主要的转换逻辑都在这个类中。
- 构造函数：__init__ 用来初始化输入文件、输出文件、转换模式、起始行、校验方式以及是否输出详细信息的参数。
- convert 方法：是脚本的核心方法，负责读取输入文件、进行转换、生成输出文件。
- binary_to_hex 方法：将二进制字符串转换为十六进制字符串。
- hex_to_binary 方法：将十六进制字符串转换为二进制字符串。
- add_parity_bit 方法：根据指定的奇偶校验方式，向数据的左边添加校验位。
- extract_suffix 方法：从行尾提取符号（如逗号、分号等）并保留，确保输出文件与输入文件格式一致。
parse_arguments 函数：
- 该函数使用 argparse模块解析命令行参数。支持的参数包括：
  - -i 或 --input：输入文件路径（必选项）。
  - -o 或 --output：输出文件路径（必选项）。
  - -m 或 --mode：转换模式，bin2hex 或 hex2bin（必选项）。
  - -s 或 --start-line：从第几行开始转换（可选，默认为1）。
  - -p 或 --parity：奇偶校验方式，odd、even 或 none（默认为 none）。
  - -v 或 --verbose：启用详细输出信息（可选，默认不输出）。
主程序：
- 通过 parse_arguments 函数解析命令行参数，创建 BaseConverter 类的实例，并调用 convert 方法进行转换。

详细功能解释：

进制转换：
- 二进制转十六进制：通过去掉输入中的空格后，将整个二进制字符串转为十六进制表示。比如，输入 01011010 转换为 5A。
- 十六进制转二进制：将十六进制字符串转为二进制字符串，并通过 zfill 方法补齐到合适的长度。比如，输入 1A 转换为 00011010。
奇偶校验：
- 校验位是根据数据中 1 的个数来决定的：
  - 如果选择 奇校验（odd），则如果数据中 1 的个数是偶数，则加上 1，使得 1 的个数变为奇数；如果 1 的个数已经是奇数，则加上 0。
  - 如果选择 偶校验（even），则如果数据中 1 的个数是偶数，则加上 0，使得 1 的个数保持偶数；如果 1 的个数是奇数，则加上 1。
- 校验位会添加到转换后的结果的最前面。
从指定行开始处理：
- 默认从文件的第1行开始进行转换。如果文件的前几行是注释或不需要转换的内容，可以通过 -s 参数指定从哪一行开始进行转换。
保留行尾符号：
- 脚本会自动识别每行末尾的符号（如逗号、分号等），并在输出文件中保留这些符号，确保转换后的文件格式与输入文件一致。
verbose 参数控制输出：
- 如果提供 -v 参数，脚本会在每个步骤输出详细信息，帮助用户了解转换的过程。
- 默认情况下，脚本不输出任何信息，只有在启用 verbose 时才会打印输出。

示例：

1. 二进制转十六进制并启用奇校验：

1	python script.py -i input.txt -o output.txt -m bin2hex -s 5 -p odd -v

这条命令将从 input.txt 的第5行开始，将每行的二进制数据转换为十六进制，并添加奇校验位，最终结果保存到 output.txt 中，且会输出详细的转换信息。

2. 十六进制转二进制并启用偶校验：

1	python script.py -i input.txt -o output.txt -m hex2bin -p even

这条命令将从 input.txt 开始转换每行的十六进制数据为二进制，并添加偶校验位，最终结果保存到 output.txt 中，不会输出任何详细信息（因为没有指定 -v）。

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