Why Python is called Dynamically Typed?

Python is a dynamically typed language, unlike statically typed languages such as C, C++, or Java. In Python:

• You don’t need to declare a variable’s type explicitly.
• The type is determined automatically based on the assigned value.
• A variable’s type can change during program execution.

In contrast, statically typed languages require declaring a variable’s type upfront and type cannot change later. Let's see an example:

Example: This code demonstrates how a variable in Python can change its type at runtime without explicit type declaration.

x = 10  # integer
print(type(x))

x = "Hello"  # string
print(type(x))

x = [1, 2, 3]  # list
print(type(x))

<class 'int'>
<class 'str'>
<class 'list'>

Explanation: variable x is assigned different types integer, string and list showing that Python automatically updates variable’s type at runtime.

How Python's dynamic typing works?

1. No type declarations

In languages like C, Java and C++, variables must be declared with a specific type before use. This allows compiler to allocate correct memory and interpret values properly.

For example in C, you declare an integer as:

int x = 10;

Here, x is explicitly declared as an integer, so compiler knows it will always store an integer and allocates memory accordingly.

But in Python, declaration step is skipped. You simply write:

x = 10

Python automatically determines that x is an integer based on value assigned to it.

2. Type Assignment at Runtime

In Python, a variable’s type is determined at runtime based on value it holds. When you assign a new value, Python automatically updates variable’s type.

For example:

x = 42 # integer
x = "Hello" # string
x = [1, 2, 3] # list

Here, x changes type based on value assigned. Python figures out type on its own, which is the essence of dynamic typing.

3. Memory Management

In statically typed languages, memory allocation depends on declared type. In Python:

• Memory is managed automatically using reference counting and garbage collection.
• When a variable is reassigned, Python updates references and frees unused memory.

For example:

x = 10 # Python creates an integer object
x = "Hello" # Python links x to a new string object

4. Type Safety at Runtime

Even though Python is dynamically typed, it still checks types during execution:

For example:

x = 10
y = "Hello"
print(x + y) # Raises TypeError

Python throws a TypeError because adding an integer to a string is invalid.

• In statically typed languages, this error would be caught at compile-time.
• In Python, it is caught at runtime.

Advantages and Disadvantages of Dynamic Typing

Let's understand some of the key advantages and disadvantages of dynamic typing in Python.