Polymorphism through functions in Python

Introduction

Polymorphism lets one function work with different types of data easily. It helps write simple and flexible code.

When you want one function to handle different kinds of inputs, like numbers or text.

When you want to use the same function name but do different things based on input type.

When you want to make your code easier to expand without changing existing functions.

When you want to write cleaner code that avoids repeating similar functions for each data type.

Syntax

Python

def function_name(parameter):
    # code that works with different types of parameter
    if isinstance(parameter, int):
        # do something for int
        pass
    elif isinstance(parameter, str):
        # do something for str
        pass
    else:
        # default action
        pass

You can check the type of input inside the function using isinstance().

The same function name can handle different input types by using conditions.

Examples

This function prints differently based on whether the input is a number or text.

Python

def show(value):
    if isinstance(value, int):
        print(f"Number: {value}")
    elif isinstance(value, str):
        print(f"Text: {value}")
    else:
        print("Unknown type")

This simple function adds two inputs. It works for numbers or strings (concatenation).

Python

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

Sample Program

This program shows how one function describe can handle different data types and print messages accordingly.

Python

def describe(item):
    if isinstance(item, int):
        print(f"This is an integer: {item}")
    elif isinstance(item, str):
        print(f"This is a string: '{item}'")
    elif isinstance(item, list):
        print(f"This is a list with {len(item)} items")
    else:
        print("Unknown type")

# Test the function with different types
describe(10)
describe("hello")
describe([1, 2, 3])
describe(3.14)

Important Notes

Polymorphism through functions helps keep code simple and easy to read.

Using isinstance() is a common way to check input types inside a function.

Python also supports polymorphism naturally with operators like + working on numbers and strings.

Summary

Polymorphism lets one function work with many data types.

Use isinstance() inside functions to handle different types.

This makes your code flexible and easier to maintain.

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