PCEP-30-02 Functions and Exceptions

Functions and Exceptions Detailed Explanation

1. Functions

Functions are one of the most fundamental building blocks in Python programming. They allow you to organize your code into reusable, modular pieces that perform specific tasks.

1.1 Definition

• A function is:
  • A reusable block of code that performs a specific task.
  • Used to improve code organization and reduce redundancy.
• Key Characteristics:
  • Input: Functions can take arguments (inputs) to customize their behavior.
  • Output: Functions can return a value as the result of their operations.
  • Reusable: Functions can be called multiple times in different parts of the program.

1.2 Creating Functions

To create a function in Python, use the def keyword followed by the function name and parentheses ().

Syntax:

def function_name(parameters):
    # code block
    return value

Example:

#Function to greet a user
def greet(name):
    return f"Hello, {name}!"

#Calling the function
print(greet("Alice"))  # Output: Hello, Alice!

1.3 Calling Functions

Functions are executed when you "call" them by their name followed by parentheses ().

Example:

#Define the function
def greet(name):
    return f"Hello, {name}!"

#Call the function
print(greet("Bob"))  # Output: Hello, Bob

1.4 Parameters and Arguments

Functions can accept data, known as parameters, which are passed to the function when it is called.

1. Positional Arguments:

   • These are matched to the function's parameters based on their position.

   def add(a, b):
      return a + b
   
   print(add(2, 3))  # Output: 5
   

2. Keyword Arguments:

   • Arguments can be specified by name, making their order irrelevant.

   def greet(name, greeting="Hello"):
      return f"{greeting}, {name}!"
   
   print(greet(name="Alice", greeting="Hi"))  # Output: Hi, Alice!
   print(greet(name="Bob"))  # Output: Hello, Bob
   

1.5 Variable-Length Arguments

Python allows functions to accept an arbitrary number of arguments using *args (for positional arguments) and **kwargs (for keyword arguments).

1. *args:

   • Used to handle variable-length positional arguments.

   def add(*numbers):
      return sum(numbers)
   
   print(add(1, 2, 3, 4))  # Output: 10
   print(add(5, 10))  # Output: 15
   

2. **kwargs:

   • Used to handle variable-length keyword arguments.

   def greet(**info):
      return f"Hello, {info['name']}!"
   
   print(greet(name="Alice", age=30))  # Output: Hello, Alice!
   

1.6 Return Values

Functions can return a result using the return statement.

Example:

def square(number):
    return number ** 2

result = square(4)
print(result)  # Output: 16

Explanation:

• The function square takes a number, computes its square, and returns the result.

1.7 Default Parameters

Default parameters allow you to define default values for function arguments. If a value is not provided when calling the function, the default value is used.

Syntax:

def function_name(parameter=default_value):
    # code block

Example:

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("Alice"))  # Output: Hello, Alice!
print(greet("Alice", "Hi"))  # Output: Hi, Alice!

Explanation:

• The greeting parameter has a default value of "Hello".
• If no value is passed for greeting, it defaults to "Hello".

1.8 Functions Without a Return Statement

Functions that do not explicitly return a value will return None by default.

Example:

def say_hello():
    print("Hello!")

result = say_hello()
print(result)  # Output: None

Explanation:

• The function say_hello() only prints a message but does not return any value.

1.9 Anonymous Functions (Lambda Functions)

Lambda functions are small, anonymous functions defined using the lambda keyword. They are often used for short, simple operations.

Syntax:

lambda arguments: expression

Example:

#A lambda function to calculate the square of a number
square = lambda x: x ** 2
print(square(5))  # Output: 25

#Using lambda in a map function
numbers = [1, 2, 3, 4]
squares = map(lambda x: x ** 2, numbers)
print(list(squares))  # Output: [1, 4, 9, 16]

1.10 Nested Functions

Functions can be defined inside other functions. These are called nested functions or inner functions.

Example:

def outer_function(outer_value):
    def inner_function(inner_value):
        return outer_value + inner_value
    return inner_function

add_five = outer_function(5)
print(add_five(10))  # Output: 15

Explanation:

• inner_function is defined inside outer_function.
• outer_function returns inner_function, which remembers the value of outer_value.

1.11 Higher-Order Functions

A higher-order function is a function that takes another function as an argument or returns a function as a result.

Examples:

1. Using a Function as an Argument:

   def apply_function(func, value):
      return func(value)
   
   print(apply_function(lambda x: x ** 2, 5))  # Output: 25
   

2. Returning a Function:

   def multiplier(factor):
      return lambda x: x * factor
   
   double = multiplier(2)
   print(double(5))  # Output: 10
   

2. Exceptions

An exception is an error that occurs during the execution of a program. Python provides tools to detect and handle these errors gracefully.

2.1 Definition

• Exceptions:
  • Errors that disrupt the normal flow of a program.
  • Examples: Division by zero, invalid type conversions, accessing unavailable resources.
  • If not handled, exceptions cause the program to terminate.

2.2 Handling Exceptions

You can handle exceptions using the try-except block.

Syntax:

try:
    # Code that may raise an exception
except ExceptionType:
    # Code to handle the exception

Example:

try:
    x = int(input("Enter a number: "))
    print(f"You entered {x}")
except ValueError:
    print("Invalid input! Please enter a valid number.")

Explanation:

• The code inside the try block is executed.
• If a ValueError occurs (e.g., entering a non-numeric value), the except block is executed.

2.3 Finally Block

The finally block is used to execute code regardless of whether an exception occurred or not. It is commonly used for cleanup operations, such as closing a file or releasing resources.

Syntax:

try:
    # Code that may raise an exception
except ExceptionType:
    # Handle the exception
finally:
    # Code that always executes

Example:

try:
    file = open("data.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("File not found!")
finally:
    print("Closing the file (if open).")
    file.close()

Explanation:

• The finally block ensures the file is closed even if an exception occurs.

2.4 Raising Exceptions

You can raise exceptions manually using the raise keyword.

Syntax:

raise ExceptionType("Error message")

Example:

def validate_age(age):
    if age < 18:
        raise ValueError("Age must be 18 or older.")
    return "Valid age"

try:
    print(validate_age(15))
except ValueError as e:
    print(e)  # Output: Age must be 18 or older.

2.5 Catching Multiple Exceptions

You can handle multiple types of exceptions in a single try-except block by specifying a tuple of exception types.

Example:

try:
    value = int(input("Enter a number: "))
    result = 10 / value
except (ValueError, ZeroDivisionError) as e:
    print(f"Error: {e}")

Explanation:

• If a ValueError or ZeroDivisionError occurs, the corresponding error message is printed.

2.6 Handling All Exceptions

To catch all exceptions, use a bare except clause. However, this is generally discouraged as it may hide unexpected issues.

Example:

try:
    result = 10 / 0
except Exception as e:
    print(f"An error occurred: {e}")

Explanation:

• The except Exception clause catches any exception and prints the error message.

2.7 Custom Exceptions

You can define your own exception classes by inheriting from the built-in Exception class.

Example:

class CustomError(Exception):
    def __init__(self, message):
        self.message = message

def validate_age(age):
    if age < 18:
        raise CustomError("Age must be 18 or older.")
    return "Valid age"

try:
    print(validate_age(15))
except CustomError as e:
    print(e.message)  # Output: Age must be 18 or older.

Explanation:

• CustomError is a user-defined exception.
• It is raised using the raise keyword when the condition is not met.

2.8 Else in Try-Except

An else block can be added after except. It runs if no exceptions are raised.

Example:

try:
    value = int(input("Enter a number: "))
except ValueError:
    print("Invalid input!")
else:
    print(f"Valid number: {value}")

Explanation:

• If no ValueError occurs, the else block runs.

2.9 Suppressing Exceptions

The contextlib.suppress method can be used to suppress specific exceptions.

Example:

from contextlib import suppress

with suppress(FileNotFoundError):
    with open("non_existent_file.txt", "r") as file:
        content = file.read()

Explanation:

• If the file does not exist, no exception is raised, and the program continues.

2.10 Best Practices for Exception Handling

1. Be Specific:

   • Catch specific exceptions rather than using a general except clause.

   try:
      x = int(input("Enter a number: "))
   except ValueError:
      print("Invalid input!")
   

2. Avoid Overusing Exceptions:

   • Use exceptions for exceptional cases, not for regular control flow.

3. Clean Up Resources:

   • Always clean up resources (e.g., close files) in a finally block or use a context manager (with statement).

4. Provide Meaningful Messages:

   • Include useful error messages to help users understand the issue.

Functions and Exceptions (Additional Content)

1. Indentation Is Required for Function Bodies

In Python, indentation is mandatory. It is not just for readability—it defines code blocks such as function bodies, loops, conditionals, etc.

Function Definition Syntax Rule:

def function_name():
    # This is the function body
    print("Hello")  # ← Must be indented

Common Mistake:

def f():
print("Hi")  # SyntaxError: expected an indented block

This will cause a SyntaxError because Python expects the function body to be indented consistently, typically using 4 spaces per indentation level.

Key Point for PCEP:

Questions may include code like the one above and ask whether it will produce an error. If indentation is missing or inconsistent, the answer is likely SyntaxError.

2. Functions Without return Implicitly Return None

If a function does not include a return statement, it implicitly returns None.

Example:

def f():
    pass

print(f())  # Output: None

Even though f() does nothing, Python automatically returns None.

Type Check:

print(type(f()))  # Output: <class 'NoneType'>

This confirms that the return value is of type NoneType, which is the type of the built-in singleton None.

Why It Matters for PCEP:

You may encounter a question asking what a function returns if it has no return statement. Always remember: the default return is None.

3. Common Exception Types and Their Descriptions

Although the PCEP exam does not require you to write complex exception handling, it does test your ability to recognize which types of errors occur in different scenarios.

Here is a quick-reference list of common Python exceptions you should recognize:

Exception Name	Description	Example
ValueError	Raised when a function receives a valid type but an invalid value	int("abc")
TypeError	Raised when an operation is performed on incompatible types	"2" + 1
ZeroDivisionError	Raised when dividing a number by zero	10 / 0
IndexError	Raised when accessing an index that’s out of range in a sequence	[1, 2][5]
KeyError	Raised when accessing a dictionary with a key that doesn’t exist	{"a":1}["b"]

Example Breakdown:

print(int("abc"))           # ValueError
print("2" + 1)              # TypeError
print(10 / 0)               # ZeroDivisionError
print([1, 2][5])            # IndexError
print({"a": 1}["b"])        # KeyError

PCEP Exam Tip:

You may be asked:
"Which line of code will raise a TypeError?"
Recognizing each exception type by its trigger condition is critical for answering such questions quickly and accurately.

Summary Table

Concept	Key Rule or Insight	Why It Matters
Indentation	Function body must be indented	Python uses indentation to define blocks
Default Return	Functions without return return None	Can affect logic flow and outputs
NoneType	Use type() to confirm default return	Clarifies behavior in exam questions
Exception Names	Know 5–6 common errors by name and cause	Used in multiple-choice logic checking