Duck typing concept in Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is duck typing in Python?

Duck typing means that Python cares about what an object can do, not what type it is. If it behaves like a duck (has duck-like methods), Python treats it like a duck.

beginner

Explain the phrase: "If it walks like a duck and quacks like a duck, it is a duck."

This phrase means that if an object has the methods and behavior expected, Python will accept it regardless of its actual type.

intermediate

How does duck typing differ from traditional type checking?

Traditional type checking verifies an object's type before using it. Duck typing skips type checks and focuses on whether the object has the needed methods or properties.

beginner

Give a simple Python example that shows duck typing.

Example:
class Duck:
    def quack(self):
        print("Quack!")

class Person:
    def quack(self):
        print("I'm quacking like a duck!")

def make_it_quack(thing):
    thing.quack()

make_it_quack(Duck())  # prints Quack!
make_it_quack(Person())  # prints I'm quacking like a duck!

intermediate

Why is duck typing useful in Python programming?

Duck typing makes code flexible and easier to extend. You can use different objects as long as they have the right behavior, without strict inheritance or type checks.

What does duck typing focus on in Python?

A The exact class or type of the object

B What methods or behavior an object has

C The memory address of the object

D The size of the object in bytes

Duck typing cares about what an object can do, not its exact type.

Which of these best describes duck typing?

A Checking if an object has required methods before using it

B Checking the object's type strictly before use

C Using only built-in types in Python

D Forcing objects to inherit from a base class

Duck typing means using an object if it has the needed methods, without strict type checks.

In duck typing, what happens if an object lacks a required method?

A Python converts the object to the correct type

B Python automatically adds the method

C Python ignores the missing method silently

D Python raises an error when the method is called

If the object does not have the method, Python raises an AttributeError when you try to use it.

Which statement is true about duck typing?

A It allows different objects to be used interchangeably if they have similar behavior

B It requires all objects to inherit from the same parent class

C It enforces strict type annotations

D It only works with built-in Python types

Duck typing allows flexibility by focusing on behavior, not inheritance or strict types.

What is a common error when duck typing fails?

A IndexError

B TypeError

C AttributeError

D SyntaxError

If an object does not have the expected method, Python raises an AttributeError.

Explain duck typing in your own words and why it is useful in Python.

Think about how Python decides if an object can be used, not what it is.

Write a simple Python function that demonstrates duck typing with two different classes.

Create two classes with the same method and a function that calls that method on any object.

Practice

1. What does duck typing in Python primarily focus on?

easy

A. Using only built-in Python types for safety

B. Checking the exact type of an object before using it

C. Using an object based on its methods and behavior, not its type

D. Restricting objects to a specific class hierarchy

Solution

1. Step 1: Understand the meaning of duck typing

   Duck typing means if an object behaves like a duck (has methods/attributes), it can be used as a duck, regardless of its actual type.

2. Step 2: Compare options with this meaning

   Only Using an object based on its methods and behavior, not its type matches this idea by focusing on behavior, not type checking.

3. Final Answer:

   Using an object based on its methods and behavior, not its type -> Option C

4. Quick Check:

   Duck typing = behavior over type [OK]

Hint: Focus on behavior, not type, to identify duck typing [OK]

Common Mistakes:

• Thinking duck typing requires strict type checks
• Confusing duck typing with inheritance
• Believing duck typing only works with built-in types

2. Which of the following Python code snippets correctly demonstrates duck typing?

easy

A. def quack(duck):
if hasattr(duck, 'quack'):
duck.quack()

class Duck:
def quack(self):
print('Quack!')

quack(Duck())

B. def quack(duck: Duck):
duck.quack()

class Duck:
def quack(self):
print('Quack!')

quack(Duck())

C. def quack(duck):
if type(duck) == Duck:
duck.quack()

class Duck:
def quack(self):
print('Quack!')

quack(Duck())

D. def quack(duck):
duck.quack()

class Duck:
def quack(self):
print('Quack!')

quack(Duck())

Solution

1. Step 1: Identify duck typing usage

   Duck typing means using an object if it has the needed method, without checking its type.

2. Step 2: Analyze each option

   def quack(duck): if hasattr(duck, 'quack'): duck.quack() class Duck: def quack(self): print('Quack!') quack(Duck()) uses hasattr to check for method presence, which fits duck typing. Options B and C check type explicitly, which is not duck typing. def quack(duck): duck.quack() class Duck: def quack(self): print('Quack!') quack(Duck()) assumes the object has the method but does not check, which is okay but less safe than A.

3. Final Answer:

   Using hasattr to check method presence before calling -> Option A

4. Quick Check:

   hasattr check = duck typing safe use [OK]

Hint: Look for method presence checks, not type checks [OK]

Common Mistakes:

• Confusing type checking with duck typing
• Ignoring method presence before calling
• Assuming duck typing requires no checks at all

3. What will be the output of the following code?

class Bird:
    def fly(self):
        print('Flying')

class Airplane:
    def fly(self):
        print('Jet flying')

objects = [Bird(), Airplane()]
for obj in objects:
    obj.fly()

medium

A. Flying\nJet flying

B. Jet flying\nFlying

C. Flying\nFlying

D. Error: fly method not found

Solution

1. Step 1: Understand the objects and their fly methods

   Bird has fly() printing 'Flying', Airplane has fly() printing 'Jet flying'.

2. Step 2: Trace the loop calling fly on each object

   First object is Bird(), prints 'Flying'. Second is Airplane(), prints 'Jet flying'.

3. Final Answer:

   Flying\nJet flying -> Option A

4. Quick Check:

   Each object's fly() runs in order [OK]

Hint: Each object's method runs in loop order [OK]

Common Mistakes:

• Assuming type matters for method call
• Mixing output order
• Expecting error due to different classes

4. Identify the error in this code using duck typing and fix it:

class Cat:
    def meow(self):
        print('Meow')

def make_sound(animal):
    animal.sound()

make_sound(Cat())

medium

A. No error, code runs fine

B. Add a sound() method to Cat class

C. Use type checking before calling sound()

D. Change animal.sound() to animal.meow()

Solution

1. Step 1: Identify the method called on the object

   Function calls animal.sound(), but Cat class has meow(), not sound().

2. Step 2: Fix the method call to match Cat's method

   Change animal.sound() to animal.meow() to call the existing method.

3. Final Answer:

   Change animal.sound() to animal.meow() -> Option D

4. Quick Check:

   Method name must match object's method [OK]

Hint: Match method names exactly when using duck typing [OK]

Common Mistakes:

• Calling a method that does not exist
• Adding unnecessary type checks
• Ignoring method name mismatch

5. You want to write a function process(item) that works with any object having a serialize() method. Which approach best uses duck typing to handle objects without serialize() safely?

hard

A. Check if type(item) == Serializer before calling serialize()

B. Use if hasattr(item, 'serialize'): before calling item.serialize()

C. Wrap item.serialize() call in try-except to catch AttributeError

D. Define a base class with serialize() and inherit all objects from it

Solution

1. Step 1: Understand duck typing safety

   Duck typing uses behavior, so checking method presence with hasattr is a safe way to confirm before calling.

2. Step 2: Compare options for best practice

   Use if hasattr(item, 'serialize'): before calling item.serialize() checks method presence explicitly, fitting duck typing. Wrap item.serialize() call in try-except to catch AttributeError uses try-except but is less clear and may hide other errors. Check if type(item) == Serializer before calling serialize() checks type, which is not duck typing. Define a base class with serialize() and inherit all objects from it requires inheritance, reducing flexibility.

3. Final Answer:

   Use if hasattr(item, 'serialize') before calling item.serialize() -> Option B

4. Quick Check:

   hasattr check = safe duck typing [OK]

Hint: Check method presence with hasattr before calling [OK]

Common Mistakes:

• Using type checks instead of behavior checks
• Ignoring method presence and causing errors
• Overusing try-except hiding bugs