Great question! Building a project-based app with a custom save format is exactly how tools like Word, Photoshop, and SolidWorks work—they serialize all your project's state (layers, text, positions, resources, etc.) into a structured file that can be reconstructed later. Here's how to implement this in Python, plus ready-to-use libraries and practical examples:

Core Concept #

Your custom format's job is to capture every piece of data needed to rebuild your project exactly as the user left it. This could include:

• Metadata (project name, creation date, app version)
• Editable elements (text boxes, shapes, images, their positions/styles)
• Linked external resources (images, audio files)

You'll need two core functions:

1. save_project(): Convert your in-memory project objects into a storable format and write it to a file.
2. load_project(): Read the file, parse its data, and reconstruct your project objects in memory.

Recommended Libraries & Approaches #

1. Python Built-in Serialization #

These are the easiest starting points for simple projects:

• pickle:
  • Pros: Serializes almost any Python object (dataclasses, custom classes) with zero extra code.
  • Cons: Unsafe for untrusted files (malicious pickle files can execute arbitrary code), and compatibility can break between Python versions. Best for internal tools or apps where you control file sources.
• json:
  • Pros: Safe, human-readable, cross-language compatible.
  • Cons: Only supports basic data types (dict, list, str, int). You'll need to convert custom objects to/from dictionaries manually. Great for simple projects or when you need interoperability.

2. Structured Data Libraries #

For more flexibility or readability:

• PyYAML:
  • Pros: More human-readable than JSON, supports comments and nested structures. Works similarly to JSON but with friendlier syntax.
  • Cons: Like JSON, requires custom serialization for complex objects. Install with pip install pyyaml.
• msgpack:
  • Pros: Binary format, smaller file sizes and faster serialization than JSON. Cross-language support.
  • Cons: Not human-readable. Install with pip install msgpack-python.

3. Custom Zip-Based Format (Best for Resource-Heavy Apps) #

If your project includes external resources (images, audio), package everything into a zip file with a custom extension (e.g., .liamproj). This keeps assets and project data together, just like Photoshop's .psd or Word's .docx (which are actually zip files under the hood!).

4. Custom Binary Format (For Full Control) #

If you need maximum performance or a completely proprietary format, use Python's struct module to define your own binary structure. This gives you full control over every byte, but requires more work to handle versioning and data validation.

Example Implementations #

Example 1: Simple Pickle-Based Save/Load #

import pickle
from dataclasses import dataclass
from typing import List

# Define your project data structures
@dataclass
class ProjectElement:
    type: str  # e.g., "text", "image", "shape"
    content: str
    position: tuple[int, int]
    style: dict

@dataclass
class Project:
    name: str
    elements: List[ProjectElement]
    canvas_size: tuple[int, int]
    version: str = "1.0"

# Save project to file
def save_project(project: Project, file_path: str):
    with open(file_path, "wb") as f:
        pickle.dump(project, f)

# Load project from file
def load_project(file_path: str) -> Project:
    with open(file_path, "rb") as f:
        return pickle.load(f)

# Usage
if __name__ == "__main__":
    # Create a test project
    test_project = Project(
        name="My First Design",
        elements=[
            ProjectElement(
                type="text",
                content="Hello World",
                position=(50, 50),
                style={"font": "Arial", "size": 24}
            )
        ],
        canvas_size=(800, 600)
    )

    # Save to custom format
    save_project(test_project, "my_design.lproj")

    # Load it back
    loaded_project = load_project("my_design.lproj")
    print(f"Loaded project: {loaded_project.name}")
    print(f"First element: {loaded_project.elements[0].content}")

Example 2: Zip-Based Format (With Assets) #

This is ideal if your app uses images or other external files:

import json
import zipfile
import os
from dataclasses import dataclass, asdict
from typing import List

@dataclass
class ProjectElement:
    type: str
    asset_path: str  # Relative path inside the zip
    position: tuple[int, int]

@dataclass
class Project:
    name: str
    elements: List[ProjectElement]
    canvas_size: tuple[int, int]
    version: str = "1.0"

def save_project_with_assets(project: Project, file_path: str, assets: list[str]):
    # Create temp directory to assemble project files
    temp_dir = "temp_project"
    os.makedirs(temp_dir, exist_ok=True)
    assets_dir = os.path.join(temp_dir, "assets")
    os.makedirs(assets_dir, exist_ok=True)

    # Copy assets to temp directory and update element paths
    for asset in assets:
        if os.path.exists(asset):
            asset_name = os.path.basename(asset)
            dest_path = os.path.join(assets_dir, asset_name)
            with open(asset, "rb") as src, open(dest_path, "wb") as dest:
                dest.write(src.read())
            # Update element paths to relative
            for elem in project.elements:
                if elem.asset_path == asset:
                    elem.asset_path = f"assets/{asset_name}"

    # Save project metadata as JSON
    project_json = asdict(project)
    with open(os.path.join(temp_dir, "project.json"), "w") as f:
        json.dump(project_json, f, indent=2)

    # Zip everything into custom format
    with zipfile.ZipFile(file_path, "w", zipfile.ZIP_DEFLATED) as zipf:
        # Add project JSON
        zipf.write(os.path.join(temp_dir, "project.json"), "project.json")
        # Add assets
        for root, _, files in os.walk(assets_dir):
            for file in files:
                full_path = os.path.join(root, file)
                zip_path = os.path.relpath(full_path, temp_dir)
                zipf.write(full_path, zip_path)

    # Clean up temp directory
    import shutil
    shutil.rmtree(temp_dir)

def load_project_with_assets(file_path: str, extract_dir: str = "loaded_project"):
    os.makedirs(extract_dir, exist_ok=True)
    # Extract zip contents
    with zipfile.ZipFile(file_path, "r") as zipf:
        zipf.extractall(extract_dir)

    # Load project JSON
    with open(os.path.join(extract_dir, "project.json"), "r") as f:
        project_data = json.load(f)

    # Reconstruct project objects
    elements = [ProjectElement(**elem) for elem in project_data["elements"]]
    # Convert relative asset paths to absolute
    for elem in elements:
        elem.asset_path = os.path.abspath(os.path.join(extract_dir, elem.asset_path))

    return Project(
        name=project_data["name"],
        elements=elements,
        canvas_size=tuple(project_data["canvas_size"]),
        version=project_data["version"]
    )

# Usage
if __name__ == "__main__":
    test_project = Project(
        name="My Image Project",
        elements=[
            ProjectElement(type="image", asset_path="logo.png", position=(100, 100))
        ],
        canvas_size=(1280, 720)
    )

    # Save with asset
    save_project_with_assets(test_project, "my_image_project.lproj", ["logo.png"])

    # Load it back
    loaded_project = load_project_with_assets("my_image_project.lproj")
    print(f"Loaded asset path: {loaded_project.elements[0].asset_path}")

Key Considerations #

• Security: Avoid pickle if your app will load files from untrusted sources—use JSON/YAML/msgpack instead, as they don't execute code.
• Version Compatibility: Add a version field to your project data. When loading, check this field and handle backward compatibility (e.g., convert old data structures to new ones).
• Data Validation: Use libraries like pydantic to validate loaded data and prevent crashes from corrupted files.
• Performance: For large projects, msgpack or custom binary formats are faster than JSON/YAML. Zip compression can reduce file sizes significantly.

内容的提问来源于stack exchange，提问作者Liam F-A