Skip to content
The Chat Archive
qwen3-235b-a22b-no-thinking· Alibaba (Qwen) LMArena Human Preference 140K

i have a 1d ndarray A and a 2d ndarray B, and I want to serialize them into json. with…

  1. User

    i have a 1d ndarray A and a 2d ndarray B, and I want to serialize them into json. with the tolist method, i get a matrix entry per line, which isnt very human readable

  2. Assistant

    You're right — when you use tolist() on NumPy arrays and then serialize them to JSON, the output for 2D arrays (like B) can be hard to read because it's nested lists without any special formatting.

    To make the JSON more human-readable, you can:

    1. Convert your arrays to Python lists using .tolist().
    2. Use pretty-printing with json.dumps(..., indent=...).

    Here’s how you can do it:

    Example

    import numpy as np
    import json
    
    # Sample data
    A = np.array([1, 2, 3])
    B = np.array([[1, 2], [3, 4]])
    
    # Convert to Python lists
    data = {
        "A": A.tolist(),
        "B": B.tolist()
    }
    
    # Serialize to pretty-printed JSON string
    json_str = json.dumps(data, indent=4)
    
    # Optional: write to a file
    with open("arrays.json", "w") as f:
        f.write(json_str)
    
    print(json_str)
    

    Output

    {
        "A": [
            1,
            2,
            3
        ],
        "B": [
            [
                1,
                2
            ],
            [
                3,
                4
            ]
        ]
    }
    

    This format is much easier to read visually.


    Bonus: Custom Formatting if You Want More Control

    If you want even more control over formatting (e.g., aligning elements or adding comments), you’d need to manually construct the JSON string or use a custom function to format the lists.

    Let me know if you'd like an example of that!

  3. User

    I have an indent=4, and no, the output of ndarray's method tolist IS NOT HUMAN-READABLE

  4. Assistant

    Ah, I see what you're saying — and you're absolutely right.

    tolist() on a NumPy array does produce deeply nested Python lists for 2D (or higher) arrays, and even with indent=4, the JSON output can still look messy or hard to parse visually — especially for large or complex arrays.

    You want something that's genuinely human-readable, not just valid JSON with indentation. So instead of serializing raw array data directly into JSON, we should transform it into a more readable format before saving.


    ✅ Goal:

    Serialize a 1D array A and a 2D array B into a human-readable JSON file, where:

    • The structure is clear.
    • Array contents are easy to scan visually.
    • You might even be able to read it without code.

    🛠️ Solution: Custom Pretty Formatter

    Here’s how to do that in a clean and readable way:

    Option 1: Convert arrays to formatted strings before JSON serialization

    import numpy as np
    import json
    
    # Sample arrays
    A = np.array([1, 2, 3])
    B = np.array([[1, 2], [3, 4]])
    
    # Helper function to pretty-format arrays
    def pretty_array(arr, indent=""):
        if arr.ndim == 1:
            return str(arr.tolist())
        elif arr.ndim == 2:
            lines = ["["]
            for i, row in enumerate(arr):
                line = "  " + str(row.tolist())
                if i < len(arr) - 1:
                    line += ","
                lines.append(line)
            lines.append("]")
            return "\n".join(lines)
        else:
            return str(arr.tolist())  # fallback
    
    # Create a dictionary with human-readable strings
    data = {
        "A": pretty_array(A),
        "B": pretty_array(B)
    }
    
    # Serialize to pretty JSON
    json_str = json.dumps(data, indent=4)
    
    # Save or print
    with open("arrays_readable.json", "w") as f:
        f.write(json_str)
    
    print(json_str)
    

    Output (in arrays_readable.json):

    {
        "A": "[1, 2, 3]",
        "B": "[\n  [1, 2],\n  [3, 4]\n]"
    }
    

    This way, when someone opens the JSON file, they’ll see:

    {
        "A": "[1, 2, 3]",
        "B": "[
          [1, 2],
          [3, 4]
        ]"
    }
    

    It's now much easier to read visually without having to mentally parse nested lists.


    💡 Alternative: Add Comments or Metadata

    If this is for documentation or config-style use, you could also go further:

    data = {
        "description": "Serialized NumPy Arrays",
        "A (1D vector)": A.tolist(),
        "B (2D matrix)": B.tolist(),
        "shape_A": A.shape,
        "shape_B": B.shape,
        "dtype_A": str(A.dtype),
        "dtype_B": str(B.dtype)
    }
    

    Then pretty-print that with indent=4.


    🧠 Final Thoughts

    • JSON isn't designed for visual formatting — it's structured data.
    • If human readability is your top priority, consider:
      • Writing to YAML (pyyaml)
      • Saving to Markdown tables (for small arrays)
      • Using .__repr__() or string conversion directly
    • For logging/debugging, sometimes printing arrays separately and saving metadata in JSON works better.

    Would you like me to show an example using Markdown or YAML instead?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.