Names, Not Variables: Understanding Dynamic Typing in Python

Introduction

Python is known for its readability and ease of use, largely due to its dynamic typing system. A common question for those new to the language (or those coming from statically typed languages like C++ or Java) is whether you can "declare" a variable without immediately assigning it a value. This tutorial explains Python’s approach to names and values, demonstrating why the concept of "declaration" differs from other languages and how to achieve similar results.

What Does It Mean to "Declare" a Variable?

In many programming languages, declaring a variable involves telling the compiler or interpreter the variable’s name and its type (e.g., integer, string, boolean) before it’s used. This allows the system to allocate memory and perform type checking.

Python takes a different approach. It doesn’t require explicit declarations. Instead, Python uses names to refer to values. When you first assign a value to a name, that name is created and bound to that value. This means that the type of the "variable" is determined dynamically – based on the value it currently holds.

Creating Names with Assignment

The act of assigning a value to a name is how you create it in Python.

x = 10  # Creates the name 'x' and assigns it the integer value 10
message = "Hello, Python!" # Creates the name 'message' and assigns it a string.

Notice there’s no keyword like int, string, or var to declare the type beforehand. Python infers the type from the value assigned.

Initializing with None

Sometimes you want to create a name and indicate that it doesn’t currently hold a meaningful value. The conventional way to do this in Python is to assign it the special value None.

result = None  # Creates 'result' and indicates it doesn't have a value yet.

if result is None:
    print("Result hasn't been calculated yet.")

None is a built-in constant representing the absence of a value. It’s often used as a placeholder or default value. This approach is far more common and Pythonic than trying to "declare" a variable without assigning it.

Avoiding NameError

What happens if you try to use a name that hasn’t been assigned a value? Python will raise a NameError:

# This will cause a NameError:
# print(y)  # 'y' hasn't been assigned a value yet.

To avoid this, you can initialize the name with None or a suitable default value before using it.

Practical Example: Finding the First Matching Item in a Sequence

Let’s consider a common scenario: finding the first item in a sequence that meets a certain condition.

sequence = [1, 2, 3, 4, 5]
value = None  # Initialize 'value' to None

for index in sequence:
    if conditionMet(index): # Assume conditionMet is a function that returns True or False
        value = index
        break

# Now you can safely use 'value'.  It will either hold the first matching
# item, or it will be None if no item met the condition.
if value is not None:
    print("Found a matching item:", value)
else:
    print("No matching item found.")

In this example, we initialize value to None. This ensures that the name exists even before the loop starts, preventing a NameError. The if value is not None: check allows us to determine whether a matching item was found.

Using locals() and globals() (Generally Discouraged)

While possible, checking if a name exists in the current scope using locals() or globals() is often considered less readable and Pythonic than initializing with None.

for index in sequence:
    if 'value' not in locals() and conditionMet(index):
        value = index
        break

This approach works, but it’s generally better to initialize with None for clarity and maintainability.

Variable Annotations (Python 3.6+)

Python 3.6 introduced variable annotations (PEP 526), allowing you to add type hints to variables:

captain: str = None # Note the initial value

This doesn’t enforce type checking at runtime (you’d need a tool like mypy for that), but it improves code readability and helps with static analysis. It’s a way to indicate the intended type of the variable, even if it’s initially None.

Conclusion

Python’s dynamic typing system doesn’t require explicit variable declarations. Instead, names are created when they are first assigned a value. Initializing with None is the most Pythonic way to create a name and indicate that it doesn’t currently hold a meaningful value. While variable annotations can improve code clarity, remember that Python remains a dynamically typed language.