Numeric types (int64, float64) in Pandas - Step-by-Step Execution

Concept Flow - Numeric types (int64, float64)

Create DataFrame with numbers

↓

Check data types of columns

↓

int64 for whole numbers

↓

float64 for decimal numbers

↓

Use types for calculations and memory

↓

End

Start with a DataFrame, check column types, identify int64 for integers and float64 for decimals, then use these types for calculations.

Execution Sample

Pandas

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [1.1, 2.2, 3.3]})
print(df.dtypes)

Create a DataFrame with integer and float columns, then print their data types.

Execution Table

Step	Action	DataFrame Content	Column 'A' dtype	Column 'B' dtype	Output
1	Create DataFrame	{'A': [1, 2, 3], 'B': [1.1, 2.2, 3.3]}	int64	float64	DataFrame created
2	Check dtypes	Same as above	int64	float64	A int64 B float64 dtype: object
3	Print dtypes	Same as above	int64	float64	Printed data types
4	End	-	-	-	Execution complete

💡 All steps done, data types identified correctly for each column.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
df	None	{'A': [1, 2, 3], 'B': [1.1, 2.2, 3.3]}	Same	Same
df['A'].dtype	None	int64	int64	int64
df['B'].dtype	None	float64	float64	float64

Key Moments - 2 Insights

Why is column 'A' int64 and not float64 even though pandas can store floats?

Because all values in column 'A' are whole numbers without decimals, pandas assigns int64 to save memory and keep data precise, as shown in execution_table step 2.

What happens if a float value is added to column 'A'?

The dtype of column 'A' would change to float64 to accommodate decimal numbers, since int64 cannot store decimals. This is implied by the difference between columns 'A' and 'B' in execution_table.

Visual Quiz - 3 Questions

Look at the execution table at step 2, what is the data type of column 'B'?

A object

B int64

C float64

D string

💡 Hint

Check the 'Column 'B' dtype' column in execution_table row for step 2.

At which step does the DataFrame get created with the numeric columns?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' column in execution_table to find when DataFrame is created.

If column 'A' had a decimal value, what would its dtype likely be?

A int64

B float64

C object

D bool

💡 Hint

Compare dtypes of columns 'A' and 'B' in execution_table to understand how decimals affect dtype.

Concept Snapshot

pandas numeric types:
- int64: stores whole numbers
- float64: stores decimal numbers
- Use df.dtypes to check column types
- Types affect memory and calculations
- Mixing decimals in int column converts it to float64

Full Transcript

We start by creating a pandas DataFrame with two columns: 'A' containing whole numbers and 'B' containing decimal numbers. We then check the data types of each column using df.dtypes. Column 'A' is assigned the int64 type because it contains only whole numbers, while column 'B' is assigned float64 because it contains decimals. These types help pandas optimize memory and calculations. If a decimal number is added to column 'A', its type would change to float64 to accommodate decimals. This step-by-step execution helps understand how pandas assigns numeric types.

Practice

1. Which pandas numeric type is best for storing whole numbers without decimals?

easy

A. bool

B. float64

C. int64

D. object

Solution

1. Step 1: Understand numeric types in pandas

   int64 is used for integers (whole numbers), float64 for decimals.

2. Step 2: Identify the type for whole numbers

   Whole numbers require int64 because float64 stores decimals.

3. Final Answer:

   int64 -> Option C

4. Quick Check:

   Whole numbers = int64 [OK]

Hint: Whole numbers use int64, decimals use float64 [OK]

Common Mistakes:

• Confusing float64 as default for all numbers
• Choosing object type for numeric data
• Using bool for numeric storage

2. Which of the following is the correct way to convert a pandas DataFrame column df['col'] to float64 type?

easy

A. df.astype('float64')['col']

B. df['col'].convert('float64')

C. astype(df['col'], 'float64')

D. df['col'].astype('float64')

Solution

1. Step 1: Recall pandas method to change column type

   The method to change a column's type is astype() called on the column.

2. Step 2: Apply correct syntax

   Use df['col'].astype('float64') to convert the column to float64.

3. Final Answer:

   df['col'].astype('float64') -> Option D

4. Quick Check:

   astype() on column = correct syntax [OK]

Hint: Use astype() on the column to change type [OK]

Common Mistakes:

• Calling astype() on the whole DataFrame incorrectly
• Using non-existent convert() method
• Wrong function syntax like astype(df['col'], 'float64')

3. Given the code:

import pandas as pd
df = pd.DataFrame({'A': [1, 2, 3], 'B': [1.0, 2.5, 3.5]})
df['A'] = df['A'].astype('float64')
print(df.dtypes)

What will be the output?

medium

A. A float64
B float64
dtype: object

B. A int64
B float64
dtype: object

C. A object
B float64
dtype: object

D. A float64
B int64
dtype: object

Solution

1. Step 1: Check initial dtypes

   Column 'A' starts as int64, 'B' as float64.

2. Step 2: Convert 'A' to float64

   Using astype('float64') changes 'A' from int64 to float64.

3. Final Answer:

   A float64 B float64 dtype: object -> Option A

4. Quick Check:

   astype changes int64 to float64 [OK]

Hint: astype changes column type; check dtypes after conversion [OK]

Common Mistakes:

• Assuming original types remain unchanged
• Confusing int64 and float64 outputs
• Misreading print output format

4. What is wrong with this code snippet?

import pandas as pd
df = pd.DataFrame({'num': [1, 2, 3]})
df['num'] = df['num'].astype(int64)

medium

A. int64 is not defined without quotes

B. astype() cannot convert to int64

C. DataFrame column cannot be reassigned

D. Missing import for astype

Solution

1. Step 1: Identify the error in astype argument

   int64 must be passed as a string 'int64', not as a bare name.

2. Step 2: Understand Python name error

   Without quotes, Python looks for a variable named int64 which is undefined.

3. Final Answer:

   int64 is not defined without quotes -> Option A

4. Quick Check:

   Use quotes around type names in astype() [OK]

Hint: Always quote type names in astype() [OK]

Common Mistakes:

• Passing type names without quotes
• Thinking astype() needs import
• Believing columns cannot be reassigned

5. You have a DataFrame df with a column 'values' containing numbers as strings, e.g., ['1', '2.5', '3']. You want to convert this column to numeric types efficiently, storing integers as int64 and decimals as float64 where needed. Which approach is best?

hard

A. Use pd.to_numeric(df['values'], downcast='integer')

B. Use pd.to_numeric(df['values'], errors='coerce') and then convert integers to int64

C. Use df['values'] = df['values'].astype('float64') for all values

D. Manually check each value and convert to int64 or float64

Solution

1. Step 1: Understand mixed numeric strings

   Strings include integers and decimals, so direct astype('float64') converts all to float.

2. Step 2: Use pd.to_numeric with errors='coerce'

   This converts strings to numbers, coercing errors to NaN, allowing safe conversion.

3. Step 3: Convert integers to int64 after identifying them

   After conversion, integers can be cast to int64 to save memory.

4. Final Answer:

   Use pd.to_numeric(df['values'], errors='coerce') and then convert integers to int64 -> Option B

5. Quick Check:

   pd.to_numeric + careful conversion handles mixed types best [OK]

Hint: Use pd.to_numeric with errors='coerce' for mixed numeric strings [OK]

Common Mistakes:

• Converting all to float64 losing integer type
• Trying manual conversion for each value
• Ignoring errors in conversion causing crashes