Polymorphism through functions in Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of polymorphic function with different types

What is the output of this code?

Python

def add(a, b):
    return a + b

print(add(5, 10))
print(add('Hello, ', 'world!'))
print(add([1, 2], [3, 4]))

A

15
TypeError
[1, 2, 3, 4]

B

15
Hello, world!
[1, 2, 3, 4]

C

15
Hello, world!
[1, 2][3, 4]

D

TypeError
Hello, world!
[1, 2, 3, 4]

💡 Hint

Think about how the + operator works differently for numbers, strings, and lists.

The add function uses the + operator, which works for integers (adds), strings (concatenates), and lists (concatenates). So all three calls succeed and print the combined results.

❓ Predict Output

intermediate

Function behavior with different input types

What will be printed when running this code?

Python

def describe(x):
    return f'Type: {type(x).__name__}, Value: {x}'

print(describe(42))
print(describe([1, 2, 3]))
print(describe({'a': 1}))

A

Type: int, Value: 42
Type: list, Value: 1, 2, 3
Type: dict, Value: {'a': 1}

B

Type: int, Value: 42
Type: list, Value: [1, 2, 3]
Type: dict, Value: {a: 1}

C

Type: int, Value: 42
Type: list, Value: [1, 2, 3]
Type: dict, Value: {'a': 1}

D

Type: int, Value: 42
Type: list, Value: [1, 2, 3]
TypeError

💡 Hint

Look at how type(x).__name__ returns the type name as a string.

The function returns a string showing the type name and the value. The dictionary prints with quotes around the key because it's a string key.

🔧 Debug

advanced

Identify the error in polymorphic function call

What error does this code raise when executed?

Python

def multiply(x, y):
    return x * y

print(multiply(3, 4))
print(multiply('Hi', 3))
print(multiply([1, 2], '2'))

A TypeError

B SyntaxError

C ValueError

D No error, prints 12, HiHiHi, [1, 2, 1, 2]

💡 Hint

Check the types of arguments in the last call and how multiplication works for lists and strings.

The last call tries to multiply a list by a string, which is not allowed and raises a TypeError. Multiplying a list by an integer repeats the list, but multiplying by a string is invalid.

❓ Predict Output

advanced

Output of polymorphic function with custom classes

What is the output of this code?

Python

class Dog:
    def speak(self):
        return 'Woof'

class Cat:
    def speak(self):
        return 'Meow'

def animal_sound(animal):
    return animal.speak()

print(animal_sound(Dog()))
print(animal_sound(Cat()))

A

Meow
Woof

B AttributeError

C

Woof
Woof

D

Woof
Meow

💡 Hint

Each class has its own speak method. The function calls the method on the passed object.

The function animal_sound calls the speak method on the object passed. Dog returns 'Woof', Cat returns 'Meow'.

🧠 Conceptual

expert

Understanding polymorphism with duck typing

Which option best explains why the following code works without errors?

def operate(x):
    return x.action()

class A:
    def action(self):
        return 'A action'

class B:
    def action(self):
        return 'B action'

print(operate(A()))
print(operate(B()))

A Because both classes have an <code>action</code> method, so <code>operate</code> can call it regardless of the object type.

B Because Python checks the type of the object before calling <code>action</code> and allows only A or B.

C Because <code>operate</code> uses inheritance to call the correct <code>action</code> method.

D Because <code>operate</code> converts objects to strings before calling <code>action</code>.

💡 Hint

Think about how Python decides if an object can do something, not what type it is.

This is duck typing: if an object has the method needed, Python allows calling it without checking the object's class explicitly.

Practice

1.

What does polymorphism through functions mean in Python?

easy

A. Functions cannot be reused with different inputs

B. Multiple functions have the same name but different parameters

C. Functions can only accept one specific data type

D. A single function works with different data types

Solution

1. Step 1: Understand polymorphism concept

   Polymorphism means one function can handle different types of inputs.

2. Step 2: Relate to function behavior

   In Python, a single function can accept various data types and behave accordingly.

3. Final Answer:

   A single function works with different data types -> Option D

4. Quick Check:

   Polymorphism = single function, many types [OK]

Hint: Think: one function, many input types [OK]

Common Mistakes:

• Confusing polymorphism with function overloading
• Believing functions accept only one data type
• Mixing polymorphism with inheritance

2.

Which of the following is the correct way to check a variable's type inside a function for polymorphism?

def process(value):
    # What to use here?
    pass

easy

A. if type(value) == int:

B. if value is int:

C. if isinstance(value, int):

D. if value == int:

Solution

1. Step 1: Recall Python type checking methods

   Using isinstance() is the recommended way to check type in Python.

2. Step 2: Compare options

   if isinstance(value, int): uses isinstance(value, int), which correctly checks if value is an int or subclass.

3. Final Answer:

   if isinstance(value, int): -> Option C

4. Quick Check:

   Use isinstance() for type checks [OK]

Hint: Use isinstance() to check types safely [OK]

Common Mistakes:

• Using 'type() == int' which fails with subclasses
• Using 'is' or '==' incorrectly for type comparison
• Not checking type at all

3.

What is the output of this code?

def describe(value):
    if isinstance(value, int):
        return f"Integer: {value}"
    elif isinstance(value, str):
        return f"String: {value}"
    else:
        return "Unknown type"

print(describe(10))
print(describe('hello'))
print(describe(3.14))

medium

A. Integer: 10\nString: hello\nUnknown type

B. Integer: 10\nString: hello\nFloat: 3.14

C. Unknown type\nUnknown type\nUnknown type

D. Integer: 10\nUnknown type\nUnknown type

Solution

1. Step 1: Check input 10

   10 is int, so returns 'Integer: 10'.

2. Step 2: Check input 'hello'

   'hello' is str, so returns 'String: hello'.

3. Step 3: Check input 3.14

   3.14 is float, not int or str, so returns 'Unknown type'.

4. Final Answer:

   Integer: 10 String: hello Unknown type -> Option A

5. Quick Check:

   Type checks match outputs [OK]

Hint: Match isinstance checks to output lines [OK]

Common Mistakes:

• Assuming float is handled like int or str
• Ignoring else case output
• Mixing output order

4.

Find the error in this polymorphic function and fix it:

def process(value):
    if isinstance(value, int):
        return value * 2
    elif isinstance(value, str):
        return value + value
    else:
        return value / 2

print(process('abc'))
print(process([1, 2, 3]))

medium

A. No error; code runs fine

B. Error: Cannot divide list by 2; fix by handling list separately

C. Error: Missing return statement for int type

D. Error: Cannot multiply string by 2; fix by converting to int

Solution

1. Step 1: Analyze input 'abc'

   String input returns 'abcabc' by concatenation, no error.

2. Step 2: Analyze input [1, 2, 3]

   List input goes to else: value / 2, but dividing list by 2 causes TypeError.

3. Step 3: Fix the error

   Need to add a check for list type or avoid dividing list by 2.

4. Final Answer:

   Error: Cannot divide list by 2; fix by handling list separately -> Option B

5. Quick Check:

   List / 2 causes error [OK]

Hint: Check operations valid for each type [OK]

Common Mistakes:

• Assuming all types support division
• Not testing with different input types
• Ignoring TypeError exceptions

5.

Write a polymorphic function combine that accepts either two strings or two lists and returns their concatenation. What is the output of this code?

def combine(a, b):
    if isinstance(a, str) and isinstance(b, str):
        return a + b
    elif isinstance(a, list) and isinstance(b, list):
        return a + b
    else:
        return None

print(combine('Hi, ', 'there!'))
print(combine([1, 2], [3, 4]))
print(combine('Hello', [1, 2]))

hard

A. 'Hi, there!'\n[1, 2, 3, 4]\nNone

B. 'Hi, there!'\n[1, 2]\n[3, 4]

C. None\nNone\nNone

D. 'Hi, there!'\nNone\nNone

Solution

1. Step 1: Check first call combine('Hi, ', 'there!')

   Both are strings, so returns concatenation 'Hi, there!'.

2. Step 2: Check second call combine([1, 2], [3, 4])

   Both are lists, so returns concatenated list [1, 2, 3, 4].

3. Step 3: Check third call combine('Hello', [1, 2])

   Types differ, so returns None.

4. Final Answer:

   'Hi, there!' [1, 2, 3, 4] None -> Option A

5. Quick Check:

   Type checks control output [OK]

Hint: Check types of both inputs before combining [OK]

Common Mistakes:

• Not checking both inputs' types
• Trying to combine different types directly
• Returning wrong default for mismatched types