When I heard about Duck Typing for the first time, I had to laugh.

But Python has surprised me before, and this time was no exception.

This is another short thread that will change the way you write code.

Here is the idea behind Duck Typing:

If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.

Taking this to Python's world, the functionality of an object is more important than its type. If the object quacks, then it's a duck.

Duck Typing is possible in dynamic languages (Hello, JavaScript fans !)

Look at the attached example. Notice how "Playground" doesn't care about the specific type of the supplied item. Instead, it assumes that the item supports the bounce() method.

To make our Playground example work, we don't need to abuse from inheritance or implement interfaces.

Duck Typing makes it possible to use whatever we need to get the work done, and we don't have to worry about a complex hierarchy of types.

Let's see other examples.

I'm sure you are familiar with len(), the function that determines how many elements are in a list.

Thanks to Duck Typing, this function will work with any class that implements a __len__() method, regardless of its type.

The attached example uses __iter__() and __next__() to prepare our Computer class with everything it needs to work with the standard for-loop construct.

Again, no need to implement specific types. If it quacks, it's a duck.

One thing to notice:

Duck Typing is closely related to the "It's Easier to Ask for Forgiveness than Permission" (EAFP) principle.

In case you are curious, I wrote about EAFP just yesterday:

https://twitter.com/svpino/status/1315149223176929280?s=20

What does this matter?

Dynamic-type advocates like myself love Duck Typing because it makes the code cleaner, explicit, and fosters reusability and flexibility without cluttering it with abstractions.

Static-type lovers have a different opinion.

But this is Python