Using appropriate dtypes in Pandas - Step-by-Step Execution

Concept Flow - Using appropriate dtypes

Load data with default dtypes

↓

Check memory usage

↓

Identify columns to optimize

↓

Convert columns to appropriate dtypes

↓

Check memory usage again

↓

Use optimized data for analysis

This flow shows loading data, checking memory, converting columns to better types, and then using optimized data.

Execution Sample

Pandas

import pandas as pd

df = pd.DataFrame({
    'A': [1, 2, 3],
    'B': ['x', 'y', 'z'],
    'C': [1.0, 2.5, 3.1]
})
df['A'] = df['A'].astype('int8')
df['B'] = df['B'].astype('category')

This code creates a DataFrame and changes column types to use less memory.

Execution Table

Step	Action	Column	Original dtype	New dtype	Memory Usage (approx)
1	Create DataFrame	A	int64	int64	24 bytes
2	Create DataFrame	B	object	object	72 bytes
3	Create DataFrame	C	float64	float64	24 bytes
4	Convert dtype	A	int64	int8	3 bytes
5	Convert dtype	B	object	category	33 bytes
6	No change	C	float64	float64	24 bytes
7	Total memory before optimization	-	-	-	120 bytes
8	Total memory after optimization	-	-	-	60 bytes

💡 Memory usage reduced by converting columns to smaller or categorical dtypes.

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
df['A'].dtype	int64	int8	int8	int8
df['B'].dtype	object	object	category	category
df['C'].dtype	float64	float64	float64	float64
Memory usage (approx)	120 bytes	99 bytes	60 bytes	60 bytes

Key Moments - 3 Insights

Why do we convert 'B' from object to category dtype?

Because 'B' contains repeated strings, converting to category saves memory by storing codes instead of full strings, as shown in steps 2 and 5 in the execution_table.

Why does converting 'A' from int64 to int8 reduce memory?

int8 uses 1 byte per value instead of 8 bytes for int64, so memory drops significantly as seen between steps 1 and 4 in the execution_table.

Why didn't we change the dtype of column 'C'?

Because 'C' contains float values that need precision, and no smaller float dtype was used here, so it remains float64 as in steps 3 and 6.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the new dtype of column 'A'?

A int8

B int64

C float64

D category

💡 Hint

Check the 'New dtype' column for step 4 in the execution_table.

At which step does the memory usage reduce to about half of the original?

A Step 5

B Step 8

C Step 6

D Step 3

💡 Hint

Look at the 'Memory Usage (approx)' column and compare total memory before and after optimization.

If column 'B' was not converted to category, what would be the approximate memory usage after step 5?

A About 33 bytes

B About 24 bytes

C About 72 bytes

D About 3 bytes

💡 Hint

Refer to the original memory usage of column 'B' at step 2 in the execution_table.

Concept Snapshot

Using appropriate dtypes in pandas:
- Load data with default types
- Check memory usage
- Convert columns to smaller types (e.g., int64 to int8)
- Convert string columns to 'category' if repeated
- Check memory again to confirm savings
- Use optimized DataFrame for faster, lighter analysis

Full Transcript

This visual execution shows how to use appropriate data types in pandas to save memory. We start by creating a DataFrame with default types: integers as int64, strings as object, and floats as float64. We check memory usage, then convert the integer column to int8 to use less space. We convert the string column to category because it has repeated values, which saves memory by storing codes instead of full strings. The float column remains unchanged. After conversions, memory usage is about half the original. This process helps make data analysis faster and more efficient by reducing memory load.