How does Python’s dynamic typing and duck typing work?

In Python, dynamic typing and duck typing are two concepts that allow for flexibility in working with data types and objects. Let’s break down each concept separately and see how they work together.

Dynamic Typing

Python is a dynamically-typed language, which means that the interpreter infers the type of a variable at runtime, rather than requiring the programmer to explicitly declare the type when the variable is created. This means you can easily change the type of a variable during the execution of a program.

For example, you could create a variable x and assign it an integer value, and later reassign it to a string value:

x = 5  # x is an integer
x = "Hello, world!"  # x is now a string

This is in contrast to statically-typed languages, where variables have fixed types that are set at the time of declaration and cannot change during the program’s execution.

Duck Typing

Duck typing is a programming concept where the type of an object is less important than the methods and properties it has. It’s based on the saying, “If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.”

In Python, duck typing allows you to use an object based on its behavior (i.e., the methods and properties it has) rather than its class or type. This is possible because Python is dynamically typed, which means that the interpreter checks the object’s compatibility with a given operation at runtime.

For example, suppose you have a function that calculates the length of a sequence:

def get_length(sequence):
    return len(sequence)

The get_length function doesn't care about the type of the input object, as long as it has a valid implementation of the __len__() method that can be called by the built-in len() function. This means you can pass different types of objects like strings, lists, or dictionaries to the function, and it will work as expected:

def get_length(sequence):
    return len(sequence)

string_length = get_length("Hello, world!")
list_length = get_length([1, 2, 3, 4, 5])
dictionary_length = get_length({"a": 1, "b": 2, "c": 3})

This flexibility provided by duck typing is one of the reasons why Python is popular and easy to work with. It allows you to write more general-purpose code without being too concerned about the specific types of objects being used.

To summarize, python’s dynamic typing allows variables to change their types during program execution, with the interpreter inferring the variable types at runtime. Duck typing, on the other hand, emphasizes an object’s behavior over its class or type, enabling the use of objects based on their methods and properties. Together, these concepts provide flexibility and ease of use in Python, allowing for more general-purpose code without strict type constraints.