Tutorials 18 min read

Pandas 3.0: Complete Guide to Copy-on-Write, String Dtype, and pd.col() Expressions

Pandas 3.0 is the biggest update in a decade. Learn about Copy-on-Write, the new PyArrow-backed string dtype, pd.col() expressions, breaking changes, and how to migrate from pandas 2.x.

Editorial Team

Introduction: Why Pandas 3.0 Is the Biggest Update in a Decade

On January 21, 2026, the pandas development team dropped pandas 3.0.0 — and honestly, calling it "just another release" would be a massive understatement. This is the most significant overhaul of Python's go-to data analysis library since Wes McKinney first created it. We're not talking about a handful of bug fixes and minor tweaks here. Pandas 3.0 fundamentally changes how the library handles memory, strings, and column operations, with real, measurable performance improvements and entire categories of bugs simply... gone.

If you've ever lost hours debugging a SettingWithCopyWarning (and let's be honest, who hasn't?), been confused about whether a slice is a view or a copy, or pulled your hair out over inconsistent string handling across DataFrames, this release was basically built for you.

The three headline features — Copy-on-Write as the default mode, a dedicated string data type, and the new pd.col() expression syntax — together represent a modernized pandas that's faster, safer, and more expressive than anything we've had before.

So, let's dive in. In this guide, we'll walk through every major change in pandas 3.0, show you practical before-and-after code examples, highlight the breaking changes you need to prepare for, and give you a step-by-step migration strategy so you can upgrade your projects with confidence.

Copy-on-Write: The End of the View vs. Copy Confusion

For years — and I mean years — the single most confusing aspect of pandas was the unpredictable behavior of indexing operations. Depending on the data layout in memory, selecting a column or slicing a DataFrame would sometimes return a view (modifying the result would modify the original) and sometimes return a copy (leaving the original untouched). This inconsistency was the root cause of the dreaded SettingWithCopyWarning and countless subtle bugs in production data pipelines.

Pandas 3.0 eliminates this confusion entirely.

Copy-on-Write (CoW) is now the default and only behavior mode. The rule is refreshingly simple: every indexing operation and method that returns a DataFrame or Series behaves as if it returns a copy. Under the hood, pandas still uses memory-efficient views, but a real copy is triggered only when you attempt to modify shared data.

How Copy-on-Write Works

Here's a quick example that shows the old, confusing behavior versus the new predictable one:

# pandas 2.x behavior (unpredictable)
import pandas as pd

df = pd.DataFrame({"foo": [1, 2, 3], "bar": [4, 5, 6]})
subset = df["foo"]
subset.iloc[0] = 100
# Did df change? It depended on internal memory layout!
# Sometimes df["foo"][0] == 100, sometimes df["foo"][0] == 1

# pandas 3.0 behavior (always predictable)
df = pd.DataFrame({"foo": [1, 2, 3], "bar": [4, 5, 6]})
subset = df["foo"]
subset.iloc[0] = 100
# df is ALWAYS unchanged. subset is its own independent copy.
print(df["foo"].iloc[0])  # Always prints 1

The internal mechanism is pretty elegant: when you extract a column or slice, pandas creates a lightweight view that shares memory with the original DataFrame. No data is copied at this point, so the operation is nearly instant. Only when you try to modify one of the objects does pandas detect the shared state and trigger an actual copy of the affected data. This "lazy copy" strategy gives you the safety of copies with the performance of views.

Chained Assignment Is Dead

One of the most common patterns that no longer works in pandas 3.0 is chained assignment — selecting data through multiple indexing operations and then assigning a value. If you've been doing this, now's the time to break the habit:

# This pattern no longer works in pandas 3.0
df = pd.DataFrame({"score": [85, 92, 78], "grade": ["B", "A", "C"]})

# Chained assignment — raises ChainedAssignmentError
df["score"][df["grade"] == "C"] = 0

# The correct approach: use .loc for direct assignment
df.loc[df["grade"] == "C", "score"] = 0
print(df)
#    score grade
# 0     85     B
# 1     92     A
# 2      0     C

Similarly, inplace operations on extracted columns no longer propagate back to the parent DataFrame:

# This no longer modifies df in pandas 3.0
df = pd.DataFrame({"price": [10.5, 20.3, 15.7]})
df["price"].replace(10.5, 11.0, inplace=True)  # df unchanged!

# Correct approaches:
# Option 1: Reassign the column
df["price"] = df["price"].replace(10.5, 11.0)

# Option 2: Use DataFrame-level inplace
df.replace({"price": {10.5: 11.0}}, inplace=True)

Performance Gains from Copy-on-Write

Because pandas now uses views internally for most operations, methods that previously created full copies are significantly faster. Operations like DataFrame.drop(axis=1), DataFrame.rename(), DataFrame.reset_index(), and DataFrame.set_index() now return views instead of copies, making them essentially free in terms of memory and computation.

And here's the really nice part — those defensive .copy() calls that were previously recommended best practice? You don't need them anymore:

# pandas 2.x: defensive copying was recommended
df_clean = df[df["value"] > 0].copy()  # .copy() to avoid warnings
df_clean["log_value"] = np.log(df_clean["value"])

# pandas 3.0: no more defensive copies needed
df_clean = df[df["value"] > 0]  # Already behaves as a copy
df_clean["log_value"] = np.log(df_clean["value"])

The copy keyword parameter has been deprecated across dozens of methods including DataFrame.reindex(), DataFrame.astype(), DataFrame.truncate(), and many more, since Copy-on-Write makes it irrelevant.

NumPy Array Interaction Under CoW

One important change that can catch experienced users off guard is how NumPy arrays interact with Copy-on-Write. When you extract a NumPy array from a DataFrame that shares data with another object, the array is now read-only by default:

import numpy as np

df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
arr = df.to_numpy()

# This now raises ValueError: assignment destination is read-only
arr[0, 0] = 100

# Solution 1: Explicitly copy
arr = df.to_numpy().copy()
arr[0, 0] = 100  # Works fine

# Solution 2: Construct without copying (use with caution)
arr = np.array(df, copy=True)
arr[0, 0] = 100  # Works fine

Also worth noting: constructing a pandas object from a NumPy array now creates a copy by default, unlike the old behavior where the DataFrame would share memory with the source array:

arr = np.array([1, 2, 3])
s = pd.Series(arr)  # Creates a copy in pandas 3.0

arr[0] = 99
print(s[0])  # Prints 1, not 99 — s is independent of arr

The New String Data Type: PyArrow-Backed Strings by Default

The second headline feature of pandas 3.0 is a dedicated string data type that replaces the old practice of storing strings as object dtype NumPy arrays. This change has been years in the making, and honestly, it's one I've been most excited about.

What Changed

In pandas 2.x and earlier, string data was stored using NumPy's object dtype — essentially an array of Python object pointers. This was inherently slow because every string operation required boxing and unboxing Python objects, and memory usage was bloated by per-object overhead.

Pandas 3.0 introduces a native str dtype backed by PyArrow (when installed) or a NumPy-based fallback. The PyArrow backend stores strings in a compact, contiguous binary format that enables vectorized operations at near-C speed:

# pandas 2.x
import pandas as pd

ser = pd.Series(["hello", "world", "pandas"])
print(ser.dtype)  # object

# pandas 3.0
ser = pd.Series(["hello", "world", "pandas"])
print(ser.dtype)  # str (backed by PyArrow if installed)

Performance Impact

The performance difference is substantial — we're talking about 5-10x faster for string operations like .str.contains(), .str.upper(), .str.replace(), and .str.split() compared to the old object dtype. Memory usage drops significantly too, because PyArrow uses a compact binary representation instead of individual Python string objects.

import pandas as pd
import numpy as np

# Create a large DataFrame with string data
n = 1_000_000
df = pd.DataFrame({
    "name": [f"user_{i}" for i in range(n)],
    "email": [f"user_{i}@example.com" for i in range(n)],
    "city": np.random.choice(["New York", "London", "Tokyo", "Paris", "Berlin"], n)
})

# String operations are dramatically faster in pandas 3.0
# These all benefit from PyArrow's vectorized string kernels
result = df["email"].str.contains("example")
upper_names = df["name"].str.upper()
domains = df["email"].str.split("@").str[1]

Breaking Changes with the New String Dtype

The new string dtype introduces several breaking changes you'll want to be aware of. Let me walk through the big ones.

1. Type checking code may break:

# pandas 2.x
ser = pd.Series(["a", "b", "c"])
if ser.dtype == "object":  # True in pandas 2.x
    print("String column detected")

# pandas 3.0 — this check no longer works!
ser = pd.Series(["a", "b", "c"])
if ser.dtype == "object":  # False in pandas 3.0
    print("This will not print")

# Correct way to check for string dtype in pandas 3.0
if pd.api.types.is_string_dtype(ser):
    print("String column detected")  # Works in both versions

2. Mixed-type columns are stricter:

# pandas 2.x: object columns could hold mixed types
ser = pd.Series(["hello", 42, None])  # Works fine, dtype: object

# pandas 3.0: string columns only accept strings
ser = pd.Series(["hello", "world"])
ser.iloc[1] = 42  # Raises TypeError — cannot assign int to str column

# If you need mixed types, explicitly use object dtype
ser = pd.Series(["hello", 42, None], dtype="object")

3. Missing values use NaN (not pd.NA):

ser = pd.Series(["hello", None, "world"])
print(ser.iloc[1])  # NaN (not pd.NA)
print(pd.isna(ser.iloc[1]))  # True

4. Only valid Unicode is accepted: When using the PyArrow backend, the string dtype only stores valid Unicode data. Byte strings or invalid encoding sequences will raise errors.

Opting Out of the New String Dtype

If you need to maintain backward compatibility or work with mixed-type string columns, you can opt out:

# Opt out globally
pd.options.future.infer_string = False

# Opt out per-column
df = pd.read_csv("data.csv", dtype={"mixed_column": "object"})

Column Expressions with pd.col(): Cleaner, Safer Method Chaining

The third major feature in pandas 3.0 is the introduction of pd.col(), a new expression syntax that lets you reference DataFrame columns by name and build up expressions without lambda functions. This might seem like syntactic sugar at first glance, but trust me — it solves real problems with readability, scoping, and method chaining.

Basic Usage

import pandas as pd

df = pd.DataFrame({
    "price": [100, 200, 150],
    "quantity": [5, 3, 8],
    "discount": [0.1, 0.2, 0.05]
})

# Old way: lambda functions
df = df.assign(
    total=lambda x: x["price"] * x["quantity"],
    discounted=lambda x: x["price"] * (1 - x["discount"])
)

# New way: pd.col() expressions
df = df.assign(
    total=pd.col("price") * pd.col("quantity"),
    discounted=pd.col("price") * (1 - pd.col("discount"))
)

print(df)
#    price  quantity  discount  total  discounted
# 0    100         5      0.10    500       90.0
# 1    200         3      0.20    600      160.0
# 2    150         8      0.05   1200      142.5

Why pd.col() Is Better Than Lambdas

There are three concrete advantages of pd.col() over lambda functions, and the first one alone is worth the switch:

1. No variable scoping bugs: Lambda functions capture variables by reference, which can lead to really nasty bugs in loops:

# Lambda scoping bug
columns = ["a", "b", "c"]
for col_name in columns:
    df = df.assign(**{f"{col_name}_squared": lambda x: x[col_name] ** 2})
# BUG: all three columns reference the last value of col_name ("c")

# pd.col() doesn't have this problem
for col_name in columns:
    df = df.assign(**{f"{col_name}_squared": pd.col(col_name) ** 2})
# Each expression correctly references its own column

2. Better readability: Expressions read more naturally, especially when chaining multiple operations. Compare lambda x: x["price"] * x["qty"] to pd.col("price") * pd.col("qty") — the intent is much clearer.

3. Full method support: pd.col() supports all standard operators and Series methods, including accessor namespaces:

# Arithmetic operators
pd.col("revenue") - pd.col("cost")

# Comparison operators
pd.col("age") >= 18

# String methods
pd.col("name").str.upper()
pd.col("email").str.contains("@gmail.com")

# Aggregation methods
pd.col("sales").sum()
pd.col("temperature").mean()

Using pd.col() with loc and Filtering

Column expressions can also be used with DataFrame.loc[] for conditional selection and assignment:

df = pd.DataFrame({
    "product": ["Widget A", "Widget B", "Widget C"],
    "price": [29.99, 49.99, 19.99],
    "stock": [100, 0, 250]
})

# Filter rows using pd.col()
in_stock = df.loc[pd.col("stock") > 0]
print(in_stock)
#      product  price  stock
# 0  Widget A  29.99    100
# 2  Widget C  19.99    250

Datetime and Timedelta Resolution Changes

This one's a bit more subtle but equally important. Pandas 3.0 changes how datetime and timedelta resolutions are inferred. Previously, all datetime operations defaulted to nanosecond resolution. Now, pandas infers the most appropriate resolution based on the input data:

# pandas 2.x: always nanosecond resolution
ts = pd.to_datetime(["2026-01-15 10:30:00"])
print(ts.dtype)  # datetime64[ns]

# pandas 3.0: infers resolution from input
ts = pd.to_datetime(["2026-01-15 10:30:00"])
print(ts.dtype)  # datetime64[us] (microsecond — matches input precision)

# Integer conversion also infers resolution
ts_seconds = pd.to_datetime([1706400000], unit="s")
print(ts_seconds.dtype)  # datetime64[s]

# stdlib datetime preserves microsecond resolution
from datetime import datetime
dt = datetime(2026, 1, 15, 10, 30, 0)
ts_stdlib = pd.to_datetime([dt])
print(ts_stdlib.dtype)  # datetime64[us]

Critical warning: If your code converts datetime values to integers (say, for serialization), the results will now differ by a factor of 1000 depending on the resolution. Use .as_unit() to normalize before casting:

# Safe way to convert to integer timestamps regardless of resolution
ts = pd.Timestamp("2026-01-15 10:30:00")
epoch_ns = ts.as_unit("ns").value  # Always nanoseconds
epoch_us = ts.as_unit("us").value  # Always microseconds
epoch_s = ts.as_unit("s").value    # Always seconds

Timezone Handling: zoneinfo Replaces pytz

Pandas 3.0 switches from pytz to Python's built-in zoneinfo module (available since Python 3.9) as the default timezone provider. This means pytz is no longer a required dependency:

# pandas 2.x
ts = pd.Timestamp("2026-01-15", tz="US/Eastern")
print(type(ts.tzinfo))  # 

# pandas 3.0
ts = pd.Timestamp("2026-01-15", tz="US/Eastern")
print(type(ts.tzinfo))  # 

# If you need pytz for backward compatibility
# pip install pandas[timezone]

The practical impact for most users is minimal, but if your code explicitly checks for pytz timezone objects or uses pytz-specific APIs like .localize(), you'll need to update those patterns.

New I/O Capabilities: Apache Iceberg Support

Pandas 3.0 adds native support for reading and writing Apache Iceberg tables through the new read_iceberg() function and DataFrame.to_iceberg() method. If you're not familiar with Iceberg, it's an open table format for large analytic datasets that provides features like schema evolution, time travel, and partition evolution — and it's becoming increasingly popular in modern data lakes.

# Reading from an Iceberg table
df = pd.read_iceberg("s3://my-bucket/warehouse/db/table")

# Writing to an Iceberg table
df.to_iceberg("s3://my-bucket/warehouse/db/output_table")

This positions pandas as a more capable participant in modern data engineering workflows, where Iceberg is rapidly becoming the go-to table format for data lakehouse architectures.

Arrow PyCapsule Interface: Zero-Copy Data Exchange

Pandas 3.0 implements the Arrow PyCapsule Interface, enabling zero-copy data exchange between different DataFrame libraries. In plain English, this means you can pass data between pandas, Polars, DuckDB, and other Arrow-compatible tools without any serialization or memory copying overhead:

import pandas as pd
import polars as pl

# Create a pandas DataFrame
pdf = pd.DataFrame({"x": [1, 2, 3], "y": [4.0, 5.0, 6.0]})

# Convert to Polars with zero-copy (via Arrow PyCapsule Interface)
plf = pl.from_pandas(pdf)

# Convert back to pandas with zero-copy
pdf2 = plf.to_pandas()

This is a big deal for workflows that combine multiple DataFrame libraries, and it shows the pandas team's commitment to interoperability with the broader data ecosystem.

Other Notable Enhancements

Anti Joins in merge()

The merge() function now supports anti joins — a feature I personally think was long overdue. It lets you find rows in one DataFrame that have no match in another:

customers = pd.DataFrame({"id": [1, 2, 3, 4], "name": ["Alice", "Bob", "Carol", "Dave"]})
orders = pd.DataFrame({"customer_id": [1, 3], "product": ["Widget", "Gadget"]})

# Find customers with no orders (anti join)
no_orders = customers.merge(
    orders,
    left_on="id",
    right_on="customer_id",
    how="anti"
)
print(no_orders)
#    id   name
# 1   2    Bob
# 3   4   Dave

Styler Export to Typst

The Styler class now supports exporting styled DataFrames to Typst, a modern typesetting system that's gaining traction as a LaTeX alternative:

styled = df.style.highlight_max(color="lightgreen")
typst_output = styled.to_typst()

Improved concat() Behavior

The concat() function now properly respects sort=False when all input DataFrames have a DatetimeIndex. Previously, the sort parameter was silently ignored in this case (which was, frankly, annoying):

df1 = pd.DataFrame({"a": [1]}, index=pd.to_datetime(["2026-01-01"]))
df2 = pd.DataFrame({"b": [2]}, index=pd.to_datetime(["2025-06-15"]))

# Now respects sort=False — maintains input order
result = pd.concat([df1, df2], axis=1, sort=False)
print(result.index)
# DatetimeIndex(['2026-01-01', '2025-06-15'], dtype='datetime64[us]')

Minimum Version Requirements

Pandas 3.0 raises the minimum required versions for Python and key dependencies:

  • Python: 3.11 or higher (was 3.10 in pandas 2.x)
  • NumPy: 1.26.0 or higher (was 1.21.0)
  • PyArrow: 13.0.0 or higher (if installed, for the string dtype backend)

Before upgrading, verify your Python version and update your dependencies accordingly:

# Check your current Python version
python --version

# Upgrade pandas
pip install --upgrade pandas

# Or with all optional dependencies
pip install --upgrade "pandas[all]"

# Verify installation
python -c "import pandas; print(pandas.__version__)"

Step-by-Step Migration Guide: Upgrading from Pandas 2.x to 3.0

Migrating to pandas 3.0 doesn't have to be painful. The pandas team designed a gradual upgrade path that lets you test and fix issues before making the full jump. Here's the approach I'd recommend:

Step 1: Upgrade to Pandas 2.3 First

Pandas 2.3 includes future-compatibility flags that let you test pandas 3.0 behaviors individually:

# In pandas 2.3, enable future behaviors one at a time
import pandas as pd

# Test Copy-on-Write behavior
pd.options.mode.copy_on_write = True

# Test new string dtype
pd.options.future.infer_string = True

Step 2: Enable All Deprecation Warnings

Run your test suite with all warnings enabled to catch deprecated patterns:

# Run tests with all warnings visible
python -W all -m pytest tests/

# Or set in code
import warnings
warnings.filterwarnings("default", category=DeprecationWarning)
warnings.filterwarnings("default", category=FutureWarning)

Step 3: Fix Common Patterns

Address the most frequent migration issues systematically. These are the ones that come up again and again:

# 1. Replace chained assignments
# Before:
df["col"][mask] = value
# After:
df.loc[mask, "col"] = value

# 2. Remove unnecessary .copy() calls
# Before:
subset = df[df["x"] > 0].copy()
# After:
subset = df[df["x"] > 0]

# 3. Update dtype checks for strings
# Before:
if df["col"].dtype == "object":
# After:
if pd.api.types.is_string_dtype(df["col"]):

# 4. Update inplace operations on extracted Series
# Before:
df["col"].fillna(0, inplace=True)
# After:
df["col"] = df["col"].fillna(0)

# 5. Replace lambda with pd.col() (optional but recommended)
# Before:
df.assign(total=lambda x: x["price"] * x["qty"])
# After:
df.assign(total=pd.col("price") * pd.col("qty"))

Step 4: Handle NumPy Interop

Review any code that extracts NumPy arrays from DataFrames and modifies them in place:

# Before: relied on shared memory between DataFrame and array
arr = df.values
arr[0, 0] = new_value  # Used to modify df too

# After: explicit copy required
arr = df.to_numpy().copy()
arr[0, 0] = new_value  # Only modifies arr

Step 5: Update Datetime Handling

If your code depends on nanosecond resolution or converts datetimes to integers, update the affected patterns:

# Before: assumed nanosecond resolution
epoch_ns = int(ts.value)  # Assumed nanosecond value

# After: use as_unit() for explicit resolution
epoch_ns = int(ts.as_unit("ns").value)  # Explicit nanosecond value

Step 6: Upgrade to Pandas 3.0

Once all tests pass with the compatibility flags enabled in pandas 2.3, you can safely upgrade:

pip install "pandas>=3.0,<4.0"

Pandas 3.0 vs. Polars: When to Use What

With these massive improvements, the question naturally arises: does pandas 3.0 close the gap with Polars? The short answer is — it narrows it, but doesn't close it entirely. Pandas 3.0 makes huge strides, especially for string operations and memory usage, but Polars still holds the edge in raw speed for large-scale data processing thanks to its Rust-based engine, native multi-threading, and lazy evaluation with query optimization.

Here's a practical decision framework:

  • Use pandas 3.0 when your datasets fit in memory (under ~10 GB), your team already knows pandas well, you rely heavily on the pandas ecosystem (scikit-learn, matplotlib, seaborn, statsmodels), or you need the broadest library compatibility.
  • Use Polars when you're processing datasets larger than available RAM, your workload is dominated by aggregations and joins on large tables, you need maximum throughput for production data pipelines, or you're starting a new project without existing pandas dependencies.
  • Use both via the Arrow PyCapsule Interface for zero-copy data exchange — pandas for exploratory analysis and ML workflows, Polars for heavy ETL processing. Honestly, this might be the sweet spot for a lot of teams.

Real-World ETL Pipeline: Before and After Pandas 3.0

Let's put everything together with a realistic ETL pipeline example that demonstrates the pandas 3.0 improvements in context:

import pandas as pd
import numpy as np

# === EXTRACT ===
# read_csv now infers string columns as str dtype automatically
transactions = pd.read_csv("transactions.csv")
customers = pd.read_csv("customers.csv")

print(transactions.dtypes)
# transaction_id      int64
# customer_id         int64
# product_name        str     <-- automatic str dtype!
# amount            float64
# transaction_date    str

# === TRANSFORM ===
# Parse dates (now infers microsecond resolution by default)
transactions["transaction_date"] = pd.to_datetime(
    transactions["transaction_date"]
)

# Clean product names — 5-10x faster with PyArrow string backend
transactions = transactions.assign(
    product_clean=pd.col("product_name").str.strip().str.lower(),
    year=pd.col("transaction_date").dt.year,
    month=pd.col("transaction_date").dt.month
)

# Filter valid transactions — no more .copy() needed!
valid = transactions[transactions["amount"] > 0]

# Use .loc for conditional updates (chained assignment no longer works)
valid.loc[valid["amount"] > 1000, "tier"] = "premium"
valid.loc[valid["amount"] <= 1000, "tier"] = "standard"

# Join with customers — anti join to find unmatched
monthly_summary = (
    valid
    .groupby(["customer_id", "year", "month"])
    .agg(
        total_spend=("amount", "sum"),
        transaction_count=("amount", "count"),
        avg_transaction=("amount", "mean")
    )
    .reset_index()
)

# Merge with customer data
result = monthly_summary.merge(customers, on="customer_id", how="left")

# Find customers with no transactions (anti join — new in 3.0!)
inactive = customers.merge(
    transactions,
    left_on="id",
    right_on="customer_id",
    how="anti"
)

# === LOAD ===
result.to_parquet("monthly_summary.parquet")
inactive.to_csv("inactive_customers.csv", index=False)

print(f"Processed {len(valid):,} transactions")
print(f"Found {len(inactive):,} inactive customers")

This pipeline benefits from every major pandas 3.0 improvement: automatic string dtype inference (no more object columns), faster string operations through PyArrow, zero defensive .copy() calls, pd.col() expressions for clean transforms, and anti joins for finding unmatched records.

Conclusion

Pandas 3.0 is, without a doubt, a watershed release for the Python data science ecosystem. Copy-on-Write eliminates an entire class of subtle bugs and removes the need for defensive copying. The new string dtype delivers 5-10x performance improvements for text-heavy workloads with essentially zero code changes. And pd.col() expressions make method chaining cleaner and safer by eliminating lambda scoping issues.

The migration path is straightforward: upgrade to pandas 2.3, enable the future compatibility flags, fix any deprecation warnings, and then upgrade to 3.0. For most codebases, the biggest changes will be replacing chained assignments with .loc and updating dtype checks from "object" to is_string_dtype().

Whether you're building ETL pipelines, training machine learning models, or doing exploratory data analysis, pandas 3.0 makes your code faster, safer, and more readable. And it does all of this while keeping the API familiarity that's made pandas the backbone of Python data science for over a decade. That's a pretty impressive feat.