Python Decorators Quiz: 20 MCQs with Answers and explanation

Python Decorators Interactive Quiz

Test your knowledge of Python decorators using decorator functions, wrapper functions, the @ syntax, function arguments, return values, and practical decorator examples.

What Are Decorators in Python?

A decorator is a function that modifies or extends the behavior of another function without directly changing its source code. Python provides convenient @decorator syntax for applying decorators.

This quiz covers:

• Python decorators
• Decorator functions
• Wrapper functions
• @decorator syntax
• Functions as objects
• Arguments and return values
• Nested functions
• Multiple decorators
• functools.wraps
• Practical decorator examples

Take this quiz to test your Python Decorators knowledge and improve your understanding of how functions can be modified and extended dynamically.

📌 Quick Summary

Python Decorators Quiz: Test your knowledge with 20 interactive multiple-choice questions covering decorator functions, wrapper functions, @ syntax, nested functions, arguments, return values, and practical Python decorator examples.

• 20 Python Decorators MCQs
• 160-second interactive quiz
• Answer explanations included
• Suitable for Python beginners and intermediate learners
• Includes output-based questions

⏱ Time Left: 160 seconds

Q1. What is a decorator in Python?

A function that modifies or extends another function's behavior
A special type of Python loop
A variable used only for storing strings
A class that can only create objects

Q2. Which symbol is commonly used to apply a decorator to a function?

@
#
$
&

Q3. What is the output?

def decorator(func): def wrapper(): print("Before") func() return wrapper @decorator def hello(): print("Hello") hello()

Before followed by Hello
Hello followed by Before
Only Hello
Only Before

Q4. What is the main purpose of a wrapper function in a decorator?

To add behavior around the decorated function
To permanently delete the decorated function
To convert every function into a class
To prevent the function from being called

Q5. What does this syntax mean?

@my_decorator def greet(): print("Hi")

The greet function is passed to my_decorator
The greet function is deleted by my_decorator
my_decorator becomes a variable inside greet
greet is converted into a class

Q6. What is the output?

def decorator(func): def wrapper(): print("Start") func() print("End") return wrapper @decorator def test(): print("Middle") test()

Start, Middle, End
Middle, Start, End
Start, End, Middle
Middle only

Q7. What does a decorator receive when it is applied to a function?

The function object
Only the function's printed output
The function's source file name only
A random integer

Q8. What is the output?

def double_result(func): def wrapper(): return func() * 2 return wrapper @double_result def number(): return 5 print(number())

10
5
7
None

Q9. Why should a general-purpose decorator often use *args and **kwargs?

To allow the wrapper to accept varying positional and keyword arguments
To force every function to have exactly two arguments
To convert arguments into strings automatically
To prevent arguments from reaching the original function

Q10. What is the output?

def decorator(func): def wrapper(*args, **kwargs): print("Called") return func(*args, **kwargs) return wrapper @decorator def add(a, b): return a + b print(add(2, 3))

Called followed by 5
5 followed by Called
Called followed by 6
None

Q11. What does functools.wraps help preserve when creating a decorator?

Metadata of the original function
The original function's local variables
The function's return value permanently
The program's global namespace

Q12. Which module provides wraps for use with decorators?

functools
decorators
wrapper
functions

Q13. What is the output?

def upper(func): def wrapper(): return func().upper() return wrapper @upper def message(): return "hello" print(message())

HELLO
hello
Hello
Error

Q14. Can a decorator return the original function without modifying it?

Yes
No, decorators must always create a wrapper
No, decorators can only return strings
No, decorators can only return classes

Q15. What happens when multiple decorators are applied to a function?

@decorator_a @decorator_b def test(): print("Test")

The decorators are applied from the closest decorator to the function outward
Only decorator_a is applied
Only decorator_b is applied
Both decorators are ignored

Q16. What is the output?

def decorator(func): def wrapper(): print("Decorator") func() return wrapper def hello(): print("Hello") hello = decorator(hello) hello()

Decorator followed by Hello
Hello followed by Decorator
Only Hello
Error

Q17. Which statement about Python decorators is correct?

Decorators can add behavior to functions without changing their original function body
Decorators can only be used with mathematical functions
Decorators always change a function into a variable
Decorators can only be defined inside classes

Q18. What is the output?

def log(func): def wrapper(): print("Running") return func() return wrapper @log def greet(): return "Hi" result = greet() print(result)

Running followed by Hi
Hi followed by Running
Running only
None

Q19. Which type of Python object can commonly be passed to a decorator?

A function
Only an integer
Only a string
Only a list

Q20. What is one common real-world use of Python decorators?

Adding logging, access checks, caching, or timing behavior to functions
Replacing the Python interpreter
Automatically converting every variable to an integer
Removing all functions from a program

Why Are Python Decorators Important?

Ans: Decorators provide a clean way to extend or modify the behavior of functions without changing their original source code. They are widely used in Python applications and frameworks.

• Add logging to functions
• Measure function execution time
• Perform authentication or access checks
• Implement caching behavior
• Validate function calls
• Reuse common functionality across multiple functions
• Understand advanced Python frameworks and libraries

❓ Frequently Asked Questions About Python Decorators

What is a decorator in Python?

A decorator is a function that takes another function as an argument and can modify or extend its behavior without directly changing the original function body.

What is the @ symbol used for in Python decorators?

The @ syntax provides a convenient way to apply a decorator to a function. For example, @my_decorator above a function applies my_decorator to that function.

What is a wrapper function?

A wrapper function is commonly defined inside a decorator and surrounds the call to the original function. It can perform additional operations before or after that call.

Why are *args and **kwargs used in decorators?

They allow a wrapper function to accept varying positional and keyword arguments and pass those arguments to the decorated function.

What is functools.wraps?

functools.wraps is a utility that helps preserve metadata from the original function when it is wrapped by a decorator.

Can decorators be applied to multiple functions?

Yes. The same decorator can be applied to multiple functions, allowing common behavior to be reused without duplicating the decorator logic.

Can Python have multiple decorators on one function?

Yes. Multiple decorators can be placed above a function. Python applies them starting with the decorator closest to the function and then works outward.

📚 Continue Learning and Testing Your Python Knowledge Step by Step:

• Python Iterators and Generators Quiz
• Python Scope and Namespace Quiz
• Python Input and Output Quiz
• Python Strings Quiz
• Python Regular Expressions Quiz

← Previous Quiz Next Quiz →