openpyxl

Openpyxl handles the bread-and-butter Excel tasks really well. Reading and writing cells, creating worksheets, and basic formatting are intuitive once you grasp the workbook/worksheet/cell hierarchy. The API feels Pythonic for common operations like `ws['A1'] = 'value'` or iterating through rows. Documentation has improved significantly with decent examples for standard use cases.

Where it gets tricky is styling and formatting - the object model for fonts, borders, and fills requires understanding nested objects and isn't always discoverable. Error messages can be cryptic when you pass invalid style objects or reference out-of-bounds cells. I've spent time in the source code figuring out why certain operations failed silently or threw generic exceptions.

Community support is decent on Stack Overflow for common problems, though GitHub issues sometimes go unresponded for weeks. The library is stable for production use, but expect to keep the docs open and do some trial-and-error with advanced formatting. Performance is reasonable for files under 10k rows, but bulk operations need careful memory management using read_only and write_only modes.

Openpyxl gets the job done for Excel manipulation but shows its age when dealing with production workloads. Memory consumption is the biggest pain point—loading a 50MB workbook can easily consume 500MB+ of RAM because it loads entire worksheets into memory. There's no streaming reader for writes, only reads, which limits your options when generating large reports. The `read_only=True` and `write_only=True` modes help but come with significant API limitations that require code restructuring.

Performance degrades noticeably beyond 10k rows. Iterating cells is slow, and styling operations are particularly expensive. There's no connection pooling concept here (it's file-based), but resource cleanup requires explicit `workbook.close()` calls or context managers—forget this and you'll leak file handles. Error messages are often cryptic, especially with malformed Excel files, and there's minimal logging instrumentation for debugging production issues.

Timeout handling is non-existent since it's synchronous I/O. The API is stable between minor versions, which is appreciated, but you'll find yourself writing wrapper functions to handle common edge cases like missing sheets or cells returning None unexpectedly.

Openpyxl gets the job done for basic Excel manipulation but shows its age in production environments. The library loads entire workbooks into memory, which becomes problematic with files over 50MB—expect several gigabytes of RAM consumption for moderately large spreadsheets. There's a read_only mode that helps, but it's limited and you lose the ability to edit cells. Write operations are similarly memory-intensive, and there's no streaming writer for large datasets.

Error handling is minimal—you'll get generic exceptions without context about which cell or row failed, making debugging painful. No built-in retry logic, connection pooling concepts don't apply, but resource cleanup requires explicit workbook.close() calls or context managers. Performance degrades noticeably beyond 100k rows; a 500k row write can take 10+ minutes. Timeout configuration doesn't exist since it's pure I/O.

The API is straightforward for simple use cases, and the documentation covers basics well. Styling support is comprehensive if you need formatted output. For small files and occasional use, it's fine, but plan for alternatives when scaling.