Introduction to Data Types in Python for Data Science

Introduction to Data Types in Python for Data Science – Complete Guide 2026

Data types are the foundation of every data science project. Choosing the right data type directly impacts memory usage, processing speed, and code reliability. In 2026, mastering Python and pandas data types is one of the quickest ways to make your workflows faster and more efficient.

TL;DR — Why Data Types Matter in Data Science

• Wrong data types can waste 5x–10x more memory
• Proper types make operations faster and prevent bugs
• Modern pandas offers nullable types and category for real-world data

1. Core Python Data Types

# Basic Python types
integer = 42                    # int
floating = 3.14159              # float
text = "Hello Data Science"     # str
boolean = True                  # bool
nothing = None                  # NoneType

# Collections
my_list = [1, 2, 3]             # list
my_tuple = (1, 2, 3)            # tuple
my_dict = {"name": "Alice"}     # dict

2. Pandas & NumPy Data Types (Most Important for Data Science)

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "customer_id": [101, 102, 103],
    "amount": [1250.75, 890.50, 2340.00],
    "region": ["North", "South", "East"],
    "is_high_value": [True, False, True],
    "order_date": pd.date_range("2026-01-01", periods=3)
})

print(df.dtypes)

# Optimized version
df_optimized = df.astype({
    "customer_id": "int32",
    "amount": "float32",
    "region": "category",
    "is_high_value": "boolean"
})

3. Common Data Type Categories in Data Science

4. Best Practices for 2026

• Always specify `dtypes` when reading CSV files
• Use `category` for any column with limited unique values
• Prefer nullable types (`Int64`, `boolean`, `string`) for real-world data
• Run `df.info(memory_usage="deep")` regularly to check memory usage
• Downcast numeric types (`float64` → `float32`) when precision allows

Mutable vs Immutable: The Distinction That Matters Most

Python types split into two groups. Immutable types (int, float, str, bool, tuple, frozenset) cannot be changed after creation — operations return new objects. Mutable types (list, dict, set) can be modified in place. This affects how values behave when you pass them to functions and whether they can be dictionary keys: only hashable (typically immutable) values can.

a = [1, 2, 3]
b = a              # b points to the SAME list
b.append(4)
print(a)           # [1, 2, 3, 4]

c = a.copy()       # independent copy
c.append(5)
print(a, c)        # [1, 2, 3, 4] [1, 2, 3, 4, 5]

print(type(42), type(3.14), type("hi"), type(None))
print(isinstance(True, int))   # True: bool is a subclass of int

Worked Example: Choosing Types for One Record

Suppose each order has an id, a price, a list of tags and a fixed (latitude, longitude) location. Picking the right type for each field makes the code self-documenting:

from decimal import Decimal

order = {
    "order_id": 5001,                       # int: whole number identifier
    "price": Decimal("19.99"),              # Decimal: exact money arithmetic
    "tags": ["gift", "express"],            # list: can grow or shrink
    "location": (31.5204, 74.3587),         # tuple: fixed pair, hashable
    "coupon": None,                         # None: explicitly "no value"
}

order["tags"].append("priority")
total = order["price"] * 3
print(total)                 # 59.97 exactly
print(0.1 + 0.2)             # 0.30000000000000004 with float
seen_locations = {order["location"]}   # tuples can go in a set
print(seen_locations)

Common Mistakes

• Comparing floats with ==: use math.isclose() because of binary rounding
• Assuming b = a copies a list: it only creates a second name for the same object
• Using a list as a dict key: raises TypeError: unhashable type; use a tuple
• Checking for missing values with == None: use is None in plain Python and isna() in pandas

Quick Summary

• Know the core types and whether each one is mutable or immutable
• Use Decimal for exact money, tuples for fixed records, lists for changing sequences
• In pandas, choose dtypes deliberately to save memory and avoid conversion bugs

Conclusion

Data types are not just technical details — they are one of the most powerful optimization tools available to data scientists. In 2026, mastering pandas data types (especially `category`, nullable types, and proper numeric downcasting) can dramatically reduce memory consumption and speed up your entire workflow.

Next steps:

• Check one of your current DataFrames with df.info(memory_usage="deep") and start optimizing the data types

Related Tutorials

• Data Types for Data Science in Python
• Lists in Python for Data Science
• Immutable vs Mutable Objects in Python 2026