Unit 4: More on OOP concepts - Practice Quiz

1 What does function overloading generally mean?

2 Does Python directly support traditional function overloading based only on parameter lists?

3 What happens when multiple functions with the same name are defined in the same Python scope?

4 Which Python feature can imitate function overloading by allowing an argument to be omitted?

5 Which parameter syntax allows a Python function to accept a variable number of positional arguments?

6 What is a common benefit of function overloading?

7 Which standard-library decorator supports dispatch based on the type of the first argument?

8 What is operator overloading in Python?

9 Which special method overloads the + operator?

10 Which special method overloads the - operator?

11 Which special method is associated with the == operator?

12 Which special method is called for the * operator?

13 What is another common name for methods such as __add__() and __sub__()?

14 If a + b is evaluated and a defines __add__(), which call does Python try?

15 Which built-in type demonstrates + with both arithmetic and concatenation behavior?

16 What is method overriding?

17 Which object-oriented concept is required for method overriding?

18 When an overridden method is called on a child-class object, which version normally runs?

19 Which function can a child class use to call the parent class implementation?

20 What does method overriding help a child class do?

21 What does the following code print?

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

def calculate(a, b, c):
return a + b + c

print(calculate(2, 3))

22 Which definition best simulates overloading a function so that it can add either two or three numbers?

23 What is the output of this code?

def total(*values):
return sum(values)

print(total(2, 4, 6))

24 A function must format either one name or a first name followed by a last name. Which signature is most suitable?

25 Given the function below, which call returns 6?

def multiply(a, b=2, c=1):
return a b c

26 Which approach provides type-based function dispatch using Python's standard library?

27 What does this function return for describe("Python")?

def describe(value):
if isinstance(value, str):
return len(value)
return value * 2

28 Which special method should a class implement to customize the behavior of the + operator?

29 What does the following code print?

class Score:
def init(self, value):
self.value = value

def add(self, other):
return Score(self.value + other.value)

result = Score(7) + Score(5)
print(result.value)

30 A Vector class should support 3 * vector when it already supports vector * 3 through __mul__. Which method should normally be added?

31 What should __add__ usually return when it cannot handle the type of the other operand?

32 Which special method is invoked by a == b to test value equality?

33 What is printed by the following code?

class Box:
def init(self, items):
self.items = items

def len(self):
return len(self.items) * 2

print(len(Box([1, 2, 3])))

34 What is the main behavioral difference between __add__ and __iadd__?

35 What does this code print?

class Animal:
def speak(self):
return "sound"

class Dog(Animal):
def speak(self):
return "bark"

pet = Dog()
print(pet.speak())

36 What is printed by this code?

class Parent:
def message(self):
return "Parent"

class Child(Parent):
def message(self):
return super().message() + " Child"

print(Child().message())

37 Which condition is essential for a subclass method to override an inherited instance method?

38 What does the following code print?

class Report:
def title(self):
return "General"

class SalesReport(Report):
pass

print(SalesReport().title())

39 Consider the classes below. What does process(EmailNotification()) return?

class Notification:
def send(self):
return "default"

class EmailNotification(Notification):
def send(self):
return "email"

def process(item):
return item.send()

40 What is the result of calling Manager().work()?

class Employee:
def work(self, hours=4):
return hours

class Manager(Employee):
def work(self, hours=4):
return super().work(hours) * 2

41 What does the following program print?

def f(x):
return x + 1

g = f

def f(x, y=3):
return x * y

print(g(4), f(4))

42 What is printed at runtime?

from typing import overload

@overload
def convert(x: int) -> str: ...

@overload
def convert(x: str) -> int: ...

def convert(x):
return x * 2

print(convert("7"), convert(7))

43 Which handler is selected by this singledispatch call?

from functools import singledispatch

@singledispatch
def label(x):
return "object"

@label.register(int)
def _(x):
return "int"

print(label(True))

44 What is the result of the final call?

from functools import singledispatch

@singledispatch
def combine(a, b):
return "base"

@combine.register(int)
def (a, b):
return "int:" + type(b).name

@combine.register(str)
def (a, b):
return "str:" + type(b).name

print(combine(1, "x"))

45 What does this program print?

from functools import singledispatchmethod

class Renderer:
@singledispatchmethod
def render(self, value, mode):
return "base"

@render.register
def _(self, value: int, mode):
return "int"

print(Renderer().render(True, "brief"))

46 What is printed by the following class definition?

class Calculator:
def calc(self, x):
return x * 10

@staticmethod
def calc(x, y=1):
return x + y

print(Calculator().calc(3))

47 What does this program print?

trace = []

class A:
def add(self, other):
trace.append("A.add")
return "left"

class B(A):
def radd(self, other):
trace.append("B.radd")
return "right"

print(A() + B(), trace)

48 What is the outcome of x + x?

log = []

class X:
def add(self, other):
log.append("add")
return NotImplemented

def radd(self, other):
log.append("radd")
return 9

x = X()
try:
x + x
except TypeError:
print(log)

49 What does the final statement print?

class Box:
def init(self, value):
self.value = value

def add(self, other):
return Box(self.value + other)

a = Box(2)
b = a
a += 3
print(a.value, b.value, a is b)

50 What happens when the final line executes?

class Key:
def init(self, value):
self.value = value

def eq(self, other):
return isinstance(other, Key) and self.value == other.value

k = Key(3)
print(hash(k))

51 What is printed by this comparison?

log = []

class A:
def lt(self, other):
log.append("A.lt")
return "left"

class B(A):
def gt(self, other):
log.append("B.gt")
return "right"

print(A() < B(), log)

52 What are the values of events and result.tag?

events = []

class Token:
def init(self, tag):
self.tag = tag

def bool(self):
events.append("bool " + self.tag)
return False

class N:
def init(self, name):
self.name = name

def lt(self, other):
tag = self.name + other.name
events.append("lt " + tag)
return Token(tag)

result = N("a") < N("b") < N("c")

53 What does the following program print?

class Bag:
def getitem(self, index):
if index >= 3:
raise IndexError
return (4, 6, 8)[index]

print(6 in Bag(), 5 in Bag())

54 What does D().m() return under Python's method resolution order?

class A:
def m(self):
return ["A"]

class B(A):
def m(self):
return ["B"] + super().m()

class C(A):
def m(self):
return ["C"] + super().m()

class D(B, C):
pass

55 How does changing C.m affect the result?

class A:
def m(self):
return ["A"]

class B(A):
def m(self):
return ["B"] + super().m()

class C(A):
def m(self):
return ["C"]

class D(B, C):
pass

result = D().m()

56 What is returned by Sub().call()?

class Base:
def call(self):
return self.step()

def step(self):
return "base"

class Sub(Base):
def __step(self):
return "sub"

result = Sub().call()

57 What does Sub().f() return?

class Base:
def f(self, x=1):
return f"B{x}"

class Sub(Base):
def f(self, x=2):
return super().f() + f"/S{x}"

58 What does constructing Sub() print?

class Base:
def init(self):
self.configure()

def configure(self):
print("base")

class Sub(Base):
def init(self):
super().init()
self.ready = True

def configure(self):
print(getattr(self, "ready", "missing"))

Sub()

59 What happens at s.x = 3?

class Base:
def init(self):
self._x = 1

@property
def x(self):
return self._x

@x.setter
def x(self, value):
self._x = value

class Sub(Base):
@property
def x(self):
return self._x * 10

s = Sub()
s.x = 3

60 What is the outcome of the final expression?

from abc import ABC, abstractmethod

class A(ABC):
@abstractmethod
def f(self):
return "A"

class B(A):
def f(self):
return super().f() + "B"

result = B().f()