Dynamic Typing in Python Explained: Examples, Pitfalls & Best Practices

video: Is Python a Dynamic Language?

• Python is a dynamically typed language. This means that the Python interpreter does type checking only as code runs, and the type of a variable is allowed to change over its lifetime.[1]
• In Python, variables are dynamic, meaning they can change types during the execution of a program. This flexibility allows you to assign a value of any type to a variable and later reassign it to a value of a different type without any issues. This dynamic nature of variables is due to Python being a dynamically typed language.

What is Dynamic Typing?

Dynamic typing means that:

• Python determines the type of a variable at runtime (while the program is running)
• You don't need to declare what type a variable is when you create it
• The same variable can hold values of different types at different times

This is different from static typing (used in languages like Java or C++) where you must declare a variable's type when you create it, and it can't change.

Dynamic Typing vs. Static Typing

Examples of Dynamic Typing in Python

1. Variable Type Changes at Runtime

my_var = 10       # my_var is an integer
print(type(my_var))  # Output: <class 'int'>
 
my_var = "Hello"  # Now my_var is a string
print(type(my_var))  # Output: <class 'str'>
 
my_var = 3.14     # Now it's a float
print(type(my_var))  # Output: <class 'float'>

Another example of variable type changes at runtime.

# Initial assignment of an integer value
x = 10
print(x)  # Output: 10
print(type(x))  # Output: <class 'int'>
 
# Reassigning a string value to the same variable
x = "Hello, World!"
print(x)  # Output: Hello, World!
print(type(x))  # Output: <class 'str'>
 
# Reassigning a list to the same variable
x = [1, 2, 3]
print(x)  # Output: [1, 2, 3]
print(type(x))  # Output: <class 'list'>
 
# Reassigning a float value to the same variable
x = 3.14
print(x)  # Output: 3.14
print(type(x))  # Output: <class 'float'>

In this example:

1. x is initially assigned an integer value of 10.
2. x is then reassigned a string value "Hello, World!".
3. x is later reassigned a list [1, 2, 3].
4. Finally, x is reassigned a float value 3.14.

Each time, the type of x changes dynamically to match the type of the value assigned to it. This flexibility is one of the powerful features of Python, allowing for more concise and adaptable code.

Example 2: No Type Declarations Needed

# In statically typed languages you might need to do:
# int age = 25
# string name = "Alice"
 
# In Python, it's much simpler:
age = 25          # Python knows it's an integer
name = "Alice"    # Python knows it's a string
price = 9.99      # Python knows it's a float

2. No Need for Explicit Type Declarations

# Python (Dynamic)
age = 25            # Automatically an int
name = "Alice"      # Automatically a str
 
# Java (Static)
# int age = 25;     # Must declare type
# String name = "Alice";

3. Functions Work with Multiple Types

def multiply(x):
    return x * 2
 
print(multiply(5))     # 10 (int)
print(multiply("A"))   # "AA" (str)
print(multiply([1,2])) # [1, 2, 1, 2] (list)

Why is Dynamic Typing Useful?

1. More flexible code: You can write functions that work with different types
2. Faster prototyping: Don't worry about types when you're experimenting
3. Less boilerplate: No need for type declarations everywhere

Common Pitfalls & How to Avoid Them

1. Type Errors in Operations

a = "10"
b = 5
print(a + b)  # TypeError (can't add str + int)

✅ Fix: Explicitly convert types

print(int(a) + b)  # 15

2. Unexpected Type Changes

count = "5"    # Meant to be int?
total = count + 10  # Error!

✅ Solution: Use type() checks

if isinstance(count, int):
    total = count + 10
else:
    count = int(count)

Type Checking & Type Hints in Python

1. Checking Types at Runtime

x = 3.14
print(type(x))          # <class 'float'>
print(isinstance(x, float))  # True

2. Optional Type Hints (Python 3.5+)

def greet(name: str) -> str:
    return "Hello, " + name

❗ Note: Type hints improve readability but don’t enforce types.

Summary

✔ Python variables do not need type declarations.
✔ The same variable can hold different types (int, str, list, etc.).
✔ Dynamic typing enables flexible functions but requires care with type mismatches.
✔ Use type() and isinstance() for runtime type checks.
✔ Type hints (e.g., variable: int) improve code clarity but are optional.

Dynamic typing makes Python easy for beginners while remaining powerful for advanced use cases.