Python中读取解析*.lis与*.dis文件的方法及工具咨询

Hey there! Dealing with unfamiliar file formats like .lis and .dis can feel like cracking a code at first—let’s break this down into actionable steps to figure out their structure and get you parsing them reliably in Python.

First, you need to know if you’re dealing with text-based or binary files—this changes everything:

• Check with a text editor: Fire up VS Code, Notepad++, or even plain old Notepad and open a small sample file. If you can read human-readable text (logs, tables, etc.), it’s text-based. If you see gibberish, it’s binary.
  • For text files: Look for patterns—are fields separated by spaces, tabs, or commas? Are there comment lines (often starting with # or ;)? Do rows follow a fixed layout (like fixed-width columns)? Jot down these patterns; they’ll be your parsing blueprint.
  • For binary files: Use a hex editor (like HxD or VS Code’s Hex Editor extension) to inspect raw bytes. Look for repeating byte sequences (these are likely records), magic numbers (unique byte sequences at the start that identify the format), or readable strings embedded in the binary. Pro tip: If you know which software generates these files, check its documentation first—this is the fastest way to get a format spec!

Once you know the format, pick the right tool for the job:

Text-Based .lis/.dis Files #

• Basic parsing with built-ins: Use Python’s open() to read lines, then split or use regex to extract fields:

  import re
  
  with open("sample.lis", "r") as f:
      for line in f:
          # Skip comment lines
          stripped_line = line.strip()
          if stripped_line.startswith("#"):
              continue
          # Split fields using regex (handles irregular spaces)
          fields = re.split(r"\s+", stripped_line)
          print(f"Parsed fields: {fields}")
  

• Structured text (like CSV variants): Use the csv module if fields are separated by a consistent delimiter (tabs, pipes, etc.):

  import csv
  
  # Use delimiter="\t" for tabs, or "|" for pipes—adjust to your file
  with open("sample.lis", "r") as f:
      reader = csv.reader(f, delimiter=" ")
      for row in reader:
          print(f"Row data: {row}")
  

• Fixed-width columns: If each field takes up a set number of characters, pandas’ read_fwf() is a lifesaver:

  import pandas as pd
  
  # Define column widths (e.g., [8, 12, 10] for three columns)
  df = pd.read_fwf("sample.lis", widths=[8, 12, 10], skiprows=1)  # skiprows to skip headers
  print(df.head())
  

Binary .lis/.dis Files #

• Basic binary parsing: Use Python’s built-in struct module to unpack bytes into readable data. You’ll need to define a format string matching the file’s structure:

  import struct
  
  with open("sample.dis", "rb") as f:
      # Example: Read a 4-byte magic number and 2-byte version (little-endian)
      magic_num, version = struct.unpack("<IH", f.read(6))
      print(f"Magic: {hex(magic_num)}, Version: {version}")
      
      # Loop to read records (e.g., 4-byte float + 10-byte string)
      while True:
          record_bytes = f.read(14)
          if not record_bytes:
              break
          value, name = struct.unpack("<f10s", record_bytes)
          # Clean up the string (remove null terminators)
          clean_name = name.decode("utf-8").strip("\x00")
          print(f"Value: {value:.2f}, Name: {clean_name}")
  

• Complex binary structures: For nested or variable-length records, use the construct library (install with pip install construct). It lets you define a blueprint for the file structure:

  from construct import Struct, Int32ul, Float32ul, String
  
  # Define a record structure
  DataRecord = Struct(
      "sensor_value" / Float32ul,
      "sensor_name" / String(10, encoding="utf-8")
  )
  
  with open("sample.dis", "rb") as f:
      # Read header first
      header = struct.unpack("<IH", f.read(6))
      print(f"File header: {header}")
      
      # Parse records until end of file
      while True:
          try:
              record = DataRecord.parse_stream(f)
              print(f"Sensor: {record.sensor_name.strip()}, Value: {record.sensor_value}")
          except EOFError:
              break
  

• If you can’t find official docs, search for the software that generates these files plus the extension (e.g., "XYZ Engineering .lis file format")—user forums or community docs often have hidden gems.
• For binary files, take a small sample where you know some data values (e.g., a temperature reading of 25.5°C) and find those bytes in the hex editor. This helps you reverse-engineer field types and order.
• If text files show gibberish, try different encodings when opening (e.g., encoding="latin-1" or encoding="utf-16")—some legacy formats use non-UTF-8 encodings.

内容的提问来源于stack exchange，提问作者Hairy