Short Answer #

Yes, you absolutely can load an XLL library with ctypes—since XLLs are just specialized Windows PE-format DLLs built for Excel. Other developers have done this successfully, though you’ll run into environment-specific hurdles (like the ones you’re seeing) that need targeted fixes.

Let’s Break Down Your Errors & Fixes #

First, let’s address the two failures you encountered:

1. 64-bit Python + 32-bit XLL: OSError: [WinError 193] %1 is not a valid Win32 application

This is a hard architecture mismatch. 64-bit processes (your 64-bit Python) cannot load 32-bit binaries, full stop. You already correctly identified your XLL is 32-bit, so sticking to a 32-bit Python environment is non-negotiable here.

2. 32-bit Python + 32-bit XLL: FileNotFoundError: Could not find module...

This almost always boils down to missing dependencies or path issues, not the XLL itself. Here’s how to fix it:

• Fix missing dependencies: XLLs often rely on auxiliary DLLs (like VC++ Runtime libraries, or other custom components your team built) that Excel knows how to find, but Python doesn’t. Use a tool like Dependency Walker to scan your alib.xll and list all dependent DLLs. Then:
  • Copy those DLLs into the same folder as your XLL, or
  • Add the folder containing the dependencies to your system PATH before loading the XLL. You can do this temporarily in Python:

    import os
    import ctypes
    
    xll_path = r"C:\public\ExcelAddons\alib.0.86\alib.xll"
    xll_dir = os.path.dirname(xll_path)
    
    # Add XLL directory to PATH so Python finds dependencies
    os.environ['PATH'] = xll_dir + os.pathsep + os.environ['PATH']
    
    # Now load the XLL
    lib = ctypes.CDLL(xll_path)
    

• Verify path correctness: Double-check for typos, spaces, or escaped characters in your path. Using raw strings (r"") avoids accidental escape issues.
• Check for locked files: Ensure no other process (like Excel) is holding the XLL open, which can prevent Python from loading it.

Known Issues & Workarounds Beyond Loading #

Even once you successfully load the XLL, you might hit these roadblocks:

• Excel runtime dependencies: Many XLL functions rely on Excel’s internal API (e.g., functions that read/write Excel cells, or use XLOPER/XLOPER12 types). If you call these functions directly in Python (without an Excel process context), you’ll get crashes or undefined behavior.

  • Workaround: Only call functions in the XLL that are pure logic (no Excel API calls). If you need to use Excel-dependent functions, run your Python code within the Excel process (e.g., using pywin32 to automate Excel and invoke the XLL functions directly in the spreadsheet).

• Name mangling for C++ XLLs: If your XLL was written in C++, the exported function names might be mangled (e.g., _MyCalculation@8 instead of MyCalculation). ctypes will fail to find the function unless you use the exact mangled name.

  • Workaround: Use Dependency Walker to get the exact exported name, then reference it directly:

    my_calc = lib._MyCalculation@8
    

  • If you control the XLL source code, wrap your exported functions in extern "C" to disable mangling.

• Type mismatches for Excel-specific types: XLLs use custom types like XLOPER/XLOPER12 for data exchange with Excel. Calling functions that use these types without proper ctypes type definitions will cause memory corruption.

  • Workaround: Define matching ctypes structures based on the Excel SDK documentation. For example:

    class XLOPER(ctypes.Structure):
        _fields_ = [
            ("xltype", ctypes.c_ushort),
            ("val", ctypes.Union([
                ("num", ctypes.c_double),
                ("str", ctypes.c_char_p),
                ("bool", ctypes.c_short)
                # Add other fields as per Excel SDK specs
            ]))
        ]
    
    # Specify argument and return types for your function
    my_func = lib.MyXLLFunction
    my_func.argtypes = [ctypes.POINTER(XLOPER)]
    my_func.restype = ctypes.POINTER(XLOPER)
    

Have Other Developers Done This? #

Absolutely. Many developers use this approach to:

• Reuse XLL-based calculation logic without launching Excel
• Test XLL functions in a Python-based automation pipeline
• Integrate XLL functionality into non-Excel Python applications

Most successful implementations focus on isolated, Excel-independent functions in the XLL—since relying on Excel’s runtime context adds significant complexity.

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