pandas

Pandas is ubiquitous for data manipulation, but running it in production environments requires careful attention to resource constraints. Memory usage scales unpredictably—a 1GB CSV can balloon to 5-10GB in RAM due to object dtypes and internal copies. The `.copy()` vs view semantics are inconsistent across operations, leading to subtle bugs where you think you're modifying a slice but aren't, or vice versa.

Performance is highly operation-dependent. Vectorized operations are fast, but chaining methods or using apply() with lambdas kills throughput. There's no built-in connection pooling for database operations—each `read_sql()` call manages its own connection, so you need to handle pooling externally. Error messages can be cryptic, especially with MultiIndex or datetime parsing failures.

The 2.0+ releases improved things with nullable dtypes and copy-on-write, but breaking changes between major versions are significant. Simple scripts written for 1.x may need refactoring for 3.0. Timeout configuration for I/O operations requires passing parameters through to underlying libraries (sqlalchemy, requests), not pandas itself. Under memory pressure, operations fail with OOM rather than gracefully degrading.

Pandas has become my go-to for any tabular data work. The official documentation is genuinely excellent - the "10 Minutes to pandas" guide gets you productive fast, and the user guide covers edge cases you'll actually encounter. Stack Overflow has answers for virtually every question, usually with multiple working solutions. The API is massive, which means there's often 3+ ways to do something, but that flexibility becomes an asset once you're past the basics.

Error messages have improved dramatically in recent versions. You'll get clear warnings about chained assignments and dtype mismatches. The gotchas are well-documented: copy vs view semantics, inplace operations, and the SettingWithCopyWarning. These can be frustrating initially, but they're protecting you from subtle bugs.

Debugging is straightforward with .head(), .dtypes, and .info() making data inspection trivial. The chaining syntax with method calls makes complex transformations readable. Performance can be an issue with very large datasets (you'll need Dask or Polars), but for most data science and analysis work under a few GB, it's perfectly capable.

Pandas remains the workhorse for data manipulation in Python, and for good reason. The DataFrame API is expressive and handles 90% of data wrangling tasks elegantly. Reading/writing various formats (CSV, Excel, SQL, Parquet) is straightforward with sensible defaults. The method chaining capability makes data pipelines readable, though you'll frequently toggle between inplace operations and returning new objects.

Type hints exist but are often too generic (DataFrame methods commonly return 'Self' or broad unions), making IDE autocompletion less helpful than it could be. You'll frequently need to check docs for whether a method modifies in-place or returns a copy. Error messages have improved significantly in recent versions, though chained operations can still produce cryptic stack traces. The SettingWithCopyWarning remains a rite of passage that confuses newcomers.

Documentation is comprehensive with good examples, but the sheer API surface area means discovering the 'right' method takes experience. Version migrations require attention—deprecation warnings are clear, but breaking changes happen. Overall, it's the pragmatic choice despite rough edges.