Convert pandas DataFrame Column to Float (astype, to_numeric & Practical Examples)

In data analysis, it is common to encounter DataFrame columns stored as strings or objects even though they represent numeric values. Converting these columns to float ensures that mathematical calculations, aggregations, and visualizations work correctly.

Pandas provides multiple ways to convert columns to float depending on the data format, presence of invalid values, or number of columns that need conversion.

Quick Reference: Convert pandas Column to Float

Method Comparison Breakdown

While the Quick Reference table focuses on syntax, this comparison explains how different pandas methods behave during conversion. This helps when deciding which method to use depending on the type and quality of your dataset.

Example: Handling invalid values with to_numeric()

import pandas as pd

df = pd.DataFrame({
    "price": ["10", "20", "invalid", "40"]
})

df["price"] = pd.to_numeric(df["price"], errors="coerce")

print(df)

In this example, "invalid" is converted to NaN instead of raising an error.

Convert a Single pandas Column to Float

Convert column to float using astype()

The most straightforward way to convert a pandas column to float is using the astype() method. This method explicitly casts the column data type to float.

import pandas as pd

df = pd.DataFrame({
    "price": [10, 20, 30, 40]
})

df["price"] = df["price"].astype(float)

print(df.dtypes)

This converts the price column from integer to float64.

Convert column to float using pd.to_numeric()

The pd.to_numeric() function is another reliable way to convert a column to float. It is especially useful when dealing with string or mixed-type data.

import pandas as pd

df = pd.DataFrame({
    "price": ["10", "20", "30", "40"]
})

df["price"] = pd.to_numeric(df["price"])

print(df.dtypes)

This method safely converts numeric strings into floating-point values.

Difference between astype() and to_numeric()

Both astype() and pd.to_numeric() can convert columns to float, but they behave differently when encountering invalid values.

Example demonstrating the difference:

import pandas as pd

df = pd.DataFrame({
    "price": ["10", "20", "invalid", "40"]
})

# safer conversion
df["price"] = pd.to_numeric(df["price"], errors="coerce")

Invalid values such as "invalid" will be converted to NaN.

Convert column to float without modifying original DataFrame

Sometimes you may want to convert a column to float without overwriting the original column. This can be done by storing the converted result in a new column.

import pandas as pd

df = pd.DataFrame({
    "price": ["10", "20", "30"]
})

df["price_float"] = df["price"].astype(float)

print(df)

This keeps the original column unchanged while creating a new float column.

Convert String or Object Column to Float

Convert string column containing numbers to float

If a column contains numeric values stored as strings, you can convert them to float using astype().

import pandas as pd

df = pd.DataFrame({
    "quantity": ["1", "2", "3", "4"]
})

df["quantity"] = df["quantity"].astype(float)

This converts the string numbers into floating-point values.

Convert object column to float safely

When a column has mixed values or uncertain formatting, using pd.to_numeric() is safer.

import pandas as pd

df = pd.DataFrame({
    "amount": ["10", "20", "30"]
})

df["amount"] = pd.to_numeric(df["amount"])

This approach helps avoid unexpected conversion errors.

Remove currency symbols before converting to float

Columns containing currency values such as $100 or ₹200 must first remove the symbols before conversion.

import pandas as pd

df = pd.DataFrame({
    "price": ["$100", "$200", "$300"]
})

df["price"] = df["price"].str.replace("$", "", regex=False).astype(float)

After removing the symbol, the column can be converted to float.

Convert percentage strings to float values

Percentage values often appear in datasets such as "45%" or "80%". These values must first remove the % sign before converting.

import pandas as pd

df = pd.DataFrame({
    "rate": ["45%", "60%", "75%"]
})

df["rate"] = df["rate"].str.rstrip("%").astype(float)

You can optionally divide by 100 if you want the values as decimal percentages.

df["rate"] = df["rate"] / 100

Handle Invalid Values During Conversion

Convert column to float ignoring invalid values

If some values cannot be converted to float, you can ignore them using errors="ignore".

import pandas as pd

df["price"] = pd.to_numeric(df["price"], errors="ignore")

This keeps invalid values unchanged while converting valid numbers.

Convert column to float and replace invalid values with NaN

The most common approach when cleaning datasets is converting invalid values to NaN.

import pandas as pd

df["price"] = pd.to_numeric(df["price"], errors="coerce")

This replaces problematic values with NaN, allowing further data cleaning.

Replace invalid values before converting to float

Sometimes datasets contain unwanted characters such as commas or text. These can be cleaned before conversion.

import pandas as pd

df = pd.DataFrame({
    "price": ["1,000", "2,500", "3,200"]
})

df["price"] = df["price"].str.replace(",", "").astype(float)

Cleaning the values first helps ensure a successful conversion.

Detect rows that failed conversion

After converting values with errors="coerce", you can identify rows that could not be converted.

import pandas as pd

df["price"] = pd.to_numeric(df["price"], errors="coerce")

invalid_rows = df[df["price"].isna()]

print(invalid_rows)

This technique helps detect problematic data entries in the dataset.

Convert Multiple Columns to Float

Convert multiple columns using astype dictionary

You can convert multiple DataFrame columns to float by passing a dictionary to the astype() method. Each key represents the column name and the value represents the target data type.

import pandas as pd

df = pd.DataFrame({
    "price": ["100", "200", "300"],
    "quantity": ["1", "2", "3"]
})

df = df.astype({
    "price": float,
    "quantity": float
})

print(df.dtypes)

This method is useful when you want to convert specific columns to float in a single operation.

Convert multiple columns using apply()

The apply() function allows you to apply a conversion function across multiple columns.

import pandas as pd

df = pd.DataFrame({
    "price": ["10", "20", "30"],
    "quantity": ["1", "2", "3"]
})

cols = ["price", "quantity"]

df[cols] = df[cols].apply(pd.to_numeric)

print(df.dtypes)

This approach is helpful when working with several columns that need similar conversions.

Convert selected columns dynamically

Sometimes you may want to dynamically convert columns based on a list or external logic.

import pandas as pd

df = pd.DataFrame({
    "price": ["10", "20", "30"],
    "quantity": ["1", "2", "3"],
    "product": ["A", "B", "C"]
})

columns_to_convert = ["price", "quantity"]

for col in columns_to_convert:
    df[col] = df[col].astype(float)

print(df.dtypes)

This technique is useful when column names are determined programmatically.

Convert columns based on data type

You can automatically detect object-type columns and convert them to float if they contain numeric values.

import pandas as pd

df = pd.DataFrame({
    "price": ["10", "20", "30"],
    "quantity": ["1", "2", "3"],
    "product": ["A", "B", "C"]
})

object_cols = df.select_dtypes(include="object").columns

df[object_cols] = df[object_cols].apply(pd.to_numeric, errors="ignore")

print(df.dtypes)

This approach helps when cleaning large datasets with unknown column types.

Convert Entire DataFrame to Float

Convert all numeric columns to float

You can convert all numeric columns in a DataFrame to float using select_dtypes().

import pandas as pd

numeric_cols = df.select_dtypes(include=["int64", "float64"]).columns

df[numeric_cols] = df[numeric_cols].astype(float)

This ensures consistent numeric data types across your dataset.

Convert all object columns to float

If object columns contain numeric values stored as strings, they can be converted to float.

import pandas as pd

object_cols = df.select_dtypes(include="object").columns

df[object_cols] = df[object_cols].apply(pd.to_numeric, errors="coerce")

Invalid values will be converted to NaN.

Convert entire DataFrame safely using to_numeric()

You can convert the entire DataFrame using pd.to_numeric() with apply().

import pandas as pd

df = df.apply(pd.to_numeric, errors="coerce")

print(df.dtypes)

This method converts all numeric-like values while safely handling invalid entries.

Convert DataFrame values using applymap()

The applymap() function applies a function to every element in the DataFrame.

import pandas as pd

df = df.applymap(lambda x: float(x) if str(x).replace(".", "", 1).isdigit() else x)

This approach converts numeric values to float while leaving other values unchanged.

Convert Data While Reading Data

Convert columns to float while loading CSV file

You can specify column data types when reading a CSV file using read_csv().

import pandas as pd

df = pd.read_csv("data.csv", dtype={
    "price": float,
    "quantity": float
})

This ensures the columns are loaded directly as floats.

Convert columns to float while reading Excel file

Similarly, you can convert columns to float after reading Excel data.

import pandas as pd

df = pd.read_excel("data.xlsx")

df["price"] = df["price"].astype(float)

This is commonly used when Excel files contain numeric values stored as text.

Define dtype during pandas read_csv()

You can also define float data types explicitly during CSV import.

import pandas as pd

df = pd.read_csv("data.csv", dtype={
    "amount": "float64"
})

This avoids additional conversion steps after loading the dataset.

Clean Data Before Converting to Float

Remove commas from numbers before conversion

Sometimes numeric values are stored with commas such as "1,000" or "2,500". These must be cleaned before converting to float.

import pandas as pd

df = pd.DataFrame({
    "price": ["1,000", "2,500", "3,200"]
})

df["price"] = df["price"].str.replace(",", "").astype(float)

print(df)

Removing commas ensures the values can be converted correctly.

Remove currency symbols

Datasets often contain currency values like $100, €200, or ₹300. These symbols must be removed before conversion.

import pandas as pd

df = pd.DataFrame({
    "price": ["$100", "$200", "$300"]
})

df["price"] = df["price"].str.replace("$", "", regex=False).astype(float)

print(df)

You can remove other currency symbols using similar replacements.

Strip whitespace before converting

Sometimes values contain leading or trailing spaces which prevent proper numeric conversion.

import pandas as pd

df = pd.DataFrame({
    "amount": [" 10 ", " 20 ", " 30 "]
})

df["amount"] = df["amount"].str.strip().astype(float)

print(df)

Using str.strip() removes unwanted whitespace before conversion.

Replace missing values before conversion

If a column contains missing values such as "NA" or empty strings, you may want to replace them before converting to float.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "price": ["10", "20", "NA", "40"]
})

df["price"] = df["price"].replace("NA", np.nan)
df["price"] = df["price"].astype(float)

print(df)

This ensures missing values are properly handled during conversion.

Convert Float With Precision Control

Convert column to float with specific decimal precision

You can control decimal precision after converting values to float using the round() function.

import pandas as pd

df = pd.DataFrame({
    "price": [10.12345, 20.56789, 30.98765]
})

df["price"] = df["price"].round(2)

print(df)

This keeps only two decimal places.

Round float values after conversion

If a column was converted from string to float, rounding can be applied afterward.

import pandas as pd

df = pd.DataFrame({
    "price": ["10.456", "20.789", "30.123"]
})

df["price"] = df["price"].astype(float).round(1)

print(df)

This converts values to float and rounds them to one decimal place.

Convert to float32 vs float64

Pandas supports multiple floating-point types such as float32 and float64.

import pandas as pd

df = pd.DataFrame({
    "price": ["10", "20", "30"]
})

df["price"] = df["price"].astype("float32")

print(df.dtypes)

float32 uses less memory compared to float64, which is useful for large datasets.

Check Data Type After Conversion

Verify column data types in pandas

After converting columns, you can verify the data types using the dtypes attribute.

import pandas as pd

print(df.dtypes)

This displays the data type of each column in the DataFrame.

Identify columns that are not numeric

You can detect columns that are not numeric using select_dtypes().

import pandas as pd

non_numeric = df.select_dtypes(exclude=["number"])

print(non_numeric.columns)

This helps identify columns that may require conversion.

Detect mixed type columns

Sometimes columns contain mixed values such as numbers and text. These columns can be detected using apply().

import pandas as pd

mixed_columns = df.columns[df.apply(lambda col: col.map(type).nunique() > 1)]

print(mixed_columns)

Mixed-type columns may require additional cleaning before conversion.

Performance Tips for Large DataFrames

Fastest way to convert columns to float

For large datasets, pd.to_numeric() with vectorized operations is usually the fastest approach.

import pandas as pd

df["price"] = pd.to_numeric(df["price"], errors="coerce")

Vectorized operations avoid slow row-by-row processing.

Memory impact of float32 vs float64

Using float32 instead of float64 can significantly reduce memory usage.

import pandas as pd

df["price"] = df["price"].astype("float32")

This is helpful when working with very large datasets.

Avoid unnecessary conversions

Repeated type conversions can slow down data processing. Always check column types before converting.

import pandas as pd

if df["price"].dtype != "float64":
    df["price"] = df["price"].astype(float)

This prevents redundant conversions and improves performance.

Summary

Converting pandas DataFrame columns to float is a common task when working with real-world datasets where numeric values may be stored as strings or objects. Pandas provides several flexible methods such as astype() and pd.to_numeric() to perform these conversions depending on the structure and quality of the data.

In this guide, we explored multiple practical scenarios including converting a single column, converting multiple columns, handling invalid values, cleaning formatted numbers, and optimizing performance for large datasets. We also discussed how to safely process data while reading files and how to control precision or memory usage using different float types.

Understanding these techniques helps ensure that your data is properly formatted for numerical operations, statistical analysis, and visualization workflows in Python.

Official Documentation

For more detailed information on pandas data type conversions, refer to the official pandas documentation:

• Pandas DataFrame astype()
• pandas to_numeric()
• pandas convert_dtypes()