Chapter 2
Functions, Modules & Packages, Exceptional Handling
2.1. Function Basics: Scope, Nested Function, Non-local Statements
Scope
- Local Scope: Variables defined inside a function. They are only accessible within
that function.
- Global Scope: Variables defined outside of all functions. They are accessible
anywhere in the code.
- Non-local Scope: Variables in the enclosing scope of a nested function (a function
defined inside another function).
Example:
x = "global"
def outer():
x = "outer"
def inner():
x = "inner" # Local scope of `inner`
print(x)
inner()
print(x) # Outer scope
outer()
print(x) # Global scope
Nested Function
A function defined within another function. It can access variables of the enclosing
function (but not global variables unless specifically declared global).
Example:
def outer_function():
x = "Hello"
def inner_function():
print(x) # Accesses the `x` from the outer function
inner_function()
outer_function()
Non-local Statements
The `nonlocal` keyword allows you to modify variables in the nearest enclosing scope
(but not global scope).
Example:
def outer():
x = "outer"
def inner():
nonlocal x # Refers to the `x` in outer function
x = "inner"
print(x)
inner()
print(x)
outer()
2.2. Built-in Functions
Python provides numerous built-in functions. These are always available for use
without importing any module.
- Common Built-in Functions:
- `print()`: Outputs data to the console.
- `len()`: Returns the length of an object.
- `type()`: Returns the type of an object.
- `max()`, `min()`: Find the maximum or minimum value.
- `sum()`: Returns the sum of all elements in an iterable.
- `sorted()`: Sorts an iterable.
- `input()`: Reads input from the user.
- `map()`, `filter()`: Apply a function to every item in an iterable or filter items based
on a function.
Example:
numbers = [1, 2, 3, 4, 5]
print(sum(numbers)) # Output: 15
print(sorted(numbers, reverse=True)) # Output: [5, 4, 3, 2, 1]
2.3. Types of Functions
User-defined Functions: Functions that are created by the user.
def greet(name):
return f"Hello, {name}"
- Anonymous Functions (Lambda): Functions defined without a name using the
`lambda` keyword. They are typically used for small, simple operations.
A lambda function is a small anonymous function.
Syntax: lambda arguments: expression
The expression is executed and the result is returned.
Lambda function can have any number of arguments but can have only one
expression.
Example of a Lambda Function:
# Lambda function to double a number
double = lambda x: x * 2
print(double(5)) # Output: 10
Lambda functions are often used with functions like `map()`, `filter()`, and `sorted()`.
Example:
numbers = [1, 2, 3, 4, 5]
# Use lambda with map to square each number
squared = map(lambda x: x ** 2, numbers)
print(list(squared)) # Output: [1, 4, 9, 16, 25]
Summary:
- Scope refers to the accessibility of variables.
- Nested functions allow functions to be defined inside other functions.
- Non-local allows access to variables from an enclosing scope.
- Python provides numerous built-in functions for common tasks.
- There are different types of functions, including anonymous functions like `lambda`
that are concise and often used for short operations.
2.4. Decorators and Generators
Decorators
A decorator is a function that modifies the behaviour of another function or class.
Decorators are often used to add functionality to existing functions in a clean and
reusable way.
- Syntax: A decorator is applied to a function using the `@decorator_name` syntax.
In python, a decorator is a design pattern that allows you to modify the
functionality of a function by wrapping it in another function.
The outer function is called the decorator, which takes the original function as an
argument and returns a modified version of it.
Example of a Simple Decorator:
def make_pretty(func):
# define the inner function
def inner():
# add some additional behaviour to decorated function
print("I got decorated")
# call original function
func()
# return the inner function
return inner
# define ordinary function
def ordinary():
print("I am ordinary")
# decorate the ordinary function
decorated_func = make_pretty(ordinary)
# call the decorated function
decorated_func()
Output
I got decorated
I am ordinary
In the example shown above, make_pretty() is a decorator.
decorated_func = make_pretty(ordinary)
We are now passing the ordinary() function as the argument to the make_pretty().
The make_pretty() function returns the inner function, and it is now assigned to the
decorated_func variable.
decorated_func()
Here, we are actually calling the inner() function, where we are printing
@ Symbol With Decorator
Instead of assigning the function call to a variable, Python provides a much more
elegant way to achieve this functionality using the @ symbol. For example,
def make_pretty(func):
def inner():
print("I got decorated")
func()
return inner
@make_pretty # ordinary = make_pretty(ordinary).
def ordinary():
print("I am ordinary")
ordinary()
Output
I got decorated
I am ordinary
Here, the ordinary() function is decorated with the make_pretty() decorator using the
@make_pretty syntax, which is equivalent to calling
ordinary = make_pretty(ordinary).
Decorators are commonly used for tasks like logging, authentication, and access
control.
Another Example of a Decorator:
def my_decorator(func):
def wrapper():
print("Before the function runs")
func()
print("After the function runs")
return wrapper
@my_decorator
def say_hello():
print("Hello!")
say_hello()
- Output:
Before the function runs
Hello!
After the function runs
Generator
A Generator in Python is a function that returns an iterator using the Yield
keyword.
In Python, a generator is a function that returns an iterator that produces a
sequence of values when iterated over.
Generators are useful when we want to produce a large sequence of values, but
we don't want to store all of them in memory at once.
Generators are defined using the `yield` keyword.
Create Python Generator
In Python, similar to defining a normal function, we can define a generator
function using the def keyword, but instead of the return statement we use the
yield statement.
If the body of a def contains yield, the function automatically becomes a Python
generator function.
def generator_name(arg):
# statements
yield something
Here, the yield keyword is used to produce a value from the generator.
When the generator function is called, it does not execute the function body
immediately. Instead, it returns a generator object that can be iterated over to
produce the values.
Example: Here's an example of a generator function that produces a sequence
of numbers,
def my_generator(n):
# initialize counter
value = 0
# loop until counter is less than n
while value < n:
# produce the current value of the counter
yield value
# increment the counter
value += 1
# iterate over the generator object produced by my_generator
for value in my_generator(3):
# print each value produced by generator
print(value)
Output
In the above example, the my_generator() generator function takes an integer
n as an argument and produces a sequence of numbers from
0 to n-1 using while loop.
The yield keyword is used to produce a value from the generator and pause the
generator function's execution until the next value is requested.
The for loop iterates over the generator object produced by my_generator() and
the print statement prints each value produced by the generator.
2.5. Modules
Basic Module Usage
A module is a Python file that contains Python code (such as functions, classes, or
variables). It helps organize code into separate files and reuse it in different programs.
- Creating a Module: You create a module by saving Python code in a `.py` file.
Example (file: `mymodule.py`):
def greet(name):
return f"Hello, {name}"
age = 25
Importing Modules
You can import a module using the `import` keyword. Once imported, you can access
the functions and variables defined in the module.
Example:
import mymodule
print(mymodule.greet("Alice")) # Output: Hello, Alice
print(mymodule.age) # Output: 25
You can also give the module a different name using the `as` keyword:
import mymodule as mm
print(mm.greet("Bob")) # Output: Hello, Bob
Types of Imports
1. Import Entire Module:
import math
print(math.sqrt(16)) # Output: 4.0
2. Import Specific Functions or Variables:
You can import specific items from a module using the `from ... import` syntax.
from math import sqrt, pi
print(sqrt(25)) # Output: 5.0
print(pi) # Output: 3.141592653589793
3. Import All Functions/Variables:
You can import everything from a module using `*`. However, this is not
recommended because it can lead to conflicts between names.
from math import *
print(sqrt(36)) # Output: 6.0
Creating and Importing Your Own Modules
To create your own module, just save a Python file with functions and variables you
want to reuse. You can import it in another script using the same syntax as built-in
modules.
1. Step 1: Create a Module File
- Save the following code in a file named `my_module.py`:
def add(a, b):
return a + b
def multiply(a, b):
return a * b
2. Step 2: Import and Use the Module
- In another Python file, you can import and use the functions:
import my_module
print(my_module.add(5, 3)) # Output: 8
print(my_module.multiply(5, 3)) # Output: 15
Importing from Submodules
If you have a package (a directory containing multiple Python files), you can organize
modules into submodules.
Example:
- Directory structure:
mypackage/
__init__.py
module1.py
module2.py
To import functions from `module1.py`:
from mypackage.module1 import my_function
2.6. Importing Functions and Variables from Different Modules
You can import functions or variables from different modules in the same program.
1. Example 1:
from math import sqrt
from random import randint
print(sqrt(49)) # Output: 7.0
print(randint(1, 10)) # Output: Random number between 1 and 10
2. Example 2:
You can import from custom modules.
- Assume you have two files: `math_operations.py` and `string_operations.py`.
- File: `math_operations.py`
def add(a, b):
return a + b
- File: `string_operations.py`
def greet(name):
return f"Hello, {name}!"
- Importing functions from both modules in another script:
from math_operations import add
from string_operations import greet
print(add(10, 5)) # Output: 15
print(greet("Alice")) # Output: Hello, Alice!
This modularity helps in organizing and maintaining your code in an efficient way,
especially for large projects.
2.7. Python Built-in Modules
Python has a wide array of built-in modules that provide various functions to help
with math, random number generation, date/time manipulation, and much more.
1. `math` Module
The `math` module provides mathematical functions.
Common functions:
- `math.sqrt(x)`: Returns the square root of `x`.
- `math.pow(x, y)`: Returns `x` raised to the power of `y`.
- `math.factorial(x)`: Returns the factorial of `x`.
- `math.pi`: Returns the value of pi.
Example:
import math
print(math.sqrt(16)) # Output: 4.0
print(math.pi) # Output: 3.141592653589793
2. `random` Module
The `random` module is used for generating random numbers.
Common functions:
- `random.random()`: Returns a random float between 0 and 1.
- `random.randint(a, b)`: Returns a random integer between `a` and `b`.
- `random.choice(sequence)`: Returns a random element from a sequence (like a list).
- `random.shuffle(list)`: Shuffles the list in place.
Example:
import random
print(random.random()) # Output: Random float between 0 and 1
print(random.randint(1, 10)) # Output: Random integer between 1 and 10
print(random.choice([1, 2, 3])) # Output: Random choice from the list
3. `datetime` Module
The `datetime` module provides classes for manipulating dates and times.
Common functions:
- `datetime.datetime.now()`: Returns the current date and time.
- `datetime.datetime.strptime()`: Parses a string into a `datetime` object.
- `datetime.timedelta()`: Represents the difference between two dates/times.
Example:
import datetime
now = datetime.datetime.now()
print(now) # Output: Current date and time
Other built-in modules include:
- `os`: Interacting with the operating system.
- `sys`: Provides access to system-specific parameters and functions.
- `time`: Provides time-related functions.
2.8. Package: Import Basics
A package is a collection of Python modules organized in directories that allow for
hierarchical structuring of modules. A package typically contains an `__init__.py` file
that makes the directory a Python package.
Creating and Importing a Package
1. Creating a Package:
- Directory structure:
mypackage/
__init__.py
module1.py
module2.py
- `module1.py`:
def hello():
return "Hello from module1!"
- `module2.py`:
def greet(name):
return f"Hello, {name}, from module2!"
2. Importing a Package:
from mypackage import module1, module2
print(module1.hello()) # Output: Hello from module1!
print(module2.greet("Alice")) # Output: Hello, Alice, from module2!
You can also import specific functions or variables from modules in the package:
from mypackage.module1 import hello
2.9. Python Namespace Packages
Namespace packages allow the distribution of a single package across multiple
directories or distributions. This is useful when multiple developers or projects want
to maintain separate sub-packages.
- Namespace Packages do not require an `__init__.py` file in their directories. They
allow different portions of a package to reside in different locations on the filesystem.
Example:
You might have:
- `mypackage/subpackage1/`
- `mypackage/subpackage2/`
Each subpackage can be in different directories, but they can still be imported as part
of the same package.
from mypackage.subpackage1 import module_a
from mypackage.subpackage2 import module_b
Namespace packages make it possible to split large packages across multiple
directories without needing to modify how they are imported.
2.10. User-Defined Modules and Packages
User-Defined Modules
A module is just a Python file (`.py`) containing Python code like functions, variables,
or classes. You can create a user-defined module by writing your Python code in a file
and importing it into other files.
1. Step 1: Create a Module File
- Example (save this code in `my_math.py`):
def add(a, b):
return a + b
def subtract(a, b):
return a - b
2. Step 2: Import and Use the Module
- In another file, you can import and use the functions:
import my_math
print(my_math.add(5, 3)) # Output: 8
print(my_math.subtract(5, 3)) # Output: 2
User-Defined Packages
A package is a collection of user-defined modules organized in a directory.
1. Step 1: Create a Package
- Directory structure:
mypackage/
__init__.py # Optional in modern Python, but used to mark a directory as a
package
my_math.py
my_string.py
- `my_math.py`:
def multiply(a, b):
return a * b
- `my_string.py`:
def uppercase(s):
return s.upper()
2. Step 2: Import and Use the Package
from mypackage import my_math, my_string
print(my_math.multiply(2, 3)) # Output: 6
print(my_string.uppercase("hello")) # Output: HELLO
Using `__init__.py`:
- If you include an `__init__.py` file in the package directory, you can also define the
package's public API or initialization code.
Example `__init__.py`:
from .my_math import multiply
from .my_string import uppercase
Now you can import from the package directly:
import mypackage
print(mypackage.multiply(2, 3)) # Output: 6
print(mypackage.uppercase("hello")) # Output: HELLO
In summary:
- Python modules and packages help organize and reuse code.
- You can create your own modules by writing Python code in `.py` files and
importing them.
- Packages allow you to organize multiple related modules into a single directory
structure.
2.11. Exception Handling
Exception handling in Python allows you to manage runtime errors gracefully,
preventing your program from crashing unexpectedly and providing useful feedback
for debugging. It uses the `try`, `except`, `else`, and `finally` blocks to handle
exceptions effectively.
2.11.1. Avoiding Code Break Using Exception Handling
When an error occurs during the execution of a program, it raises an **exception**. If
the exception is not handled, the program will terminate. Exception handling allows
us to avoid this by catching the error and taking appropriate actions.
Basic Syntax:
try:
# Code that might raise an exception
except SomeException as e:
# Code to handle the exception
Example:
try:
x = 1 / 0 # Division by zero raises an exception
except ZeroDivisionError:
print("You cannot divide by zero!")
Without exception handling, the program would crash. With exception handling, it
shows a user-friendly message.
2.11.2. Safeguarding File Operation Using Exception Handling
File operations can easily fail due to reasons such as missing files, insufficient
permissions, or incorrect file modes. To avoid these issues, you can use exception
handling to safeguard file operations.
Example:
try:
file = open('non_existent_file.txt', 'r')
content = file.read()
except FileNotFoundError:
print("The file does not exist.")
finally:
try:
file.close() # Ensure file is closed if it was opened
except NameError:
pass # File was not opened, so no need to close
In this example, if the file does not exist, the `FileNotFoundError` is caught, and an
appropriate message is shown instead of the program crashing.
2.11.3. Handling Multiple and User-Defined Exceptions
Sometimes, different exceptions may occur within the same block of code. You can
handle multiple exceptions by specifying multiple `except` clauses. Additionally,
Python allows you to define your own exceptions by creating custom exception
classes.
Handling Multiple Exceptions:
try:
x = int(input("Enter a number: "))
result = 10 / x
except ZeroDivisionError:
print("Division by zero is not allowed!")
except ValueError:
print("Invalid input! Please enter a valid number.")
User-Defined Exceptions:
You can create a custom exception by subclassing the built-in `Exception` class.
class CustomError(Exception):
pass
def check_positive(number):
if number <= 0:
raise CustomError("Number must be positive!")
try:
check_positive(-5)
except CustomError as e:
print(f"Custom Error: {e}")
2.11.4. Handling and Helping Developer with Error Code
Providing meaningful error codes and messages can help developers understand what
went wrong. When an exception is raised, you can include information about the error
to assist in debugging.
Example with Error Messages:
class InvalidAgeError(Exception):
def __init__(self, age):
self.age = age
super().__init__(f"Invalid age: {age}. Age must be between 0 and 120.")
def validate_age(age):
if age < 0 or age > 120:
raise InvalidAgeError(age)
try:
validate_age(150)
except InvalidAgeError as e:
print(f"Error: {e}")
In this case, the custom `InvalidAgeError` exception includes the invalid age and
provides a clear error message.
2.11.5. Programming Using Exception Handling
Exception handling is critical for writing robust and resilient programs. Here are some
best practices for using exception handling effectively:
1. Use Specific Exceptions: Catch specific exceptions rather than using a general
`except` block. This makes your error handling more precise and avoids masking
unexpected errors.
try:
# Code that might raise an exception
except ValueError:
# Handle ValueError specifically
2. Use `else` for Code Without Exceptions: The `else` block is executed only if no
exceptions occur, allowing you to separate exception-prone code from the rest of the
logic.
try:
result = 10 / 2
except ZeroDivisionError:
print("Cannot divide by zero.")
else:
print("Division successful:", result)
3. Use `finally` for Cleanup: The `finally` block is always executed, regardless of
whether an exception occurred. It’s useful for releasing resources like file handles,
network connections, or databases.
try:
file = open('example.txt', 'r')
content = file.read()
except FileNotFoundError:
print("File not found.")
finally:
file.close() # This will always execute, ensuring the file is closed
4. Avoid Empty `except` Blocks: Avoid using an empty `except` block that catches all
exceptions without handling them, as it can make debugging harder.
try:
# Some risky code
except Exception as e:
print(f"Error occurred: {e}") # Always print or log the error
5. Raise Exceptions When Needed: Don’t hesitate to raise exceptions in your code if
certain conditions are not met. This helps make your program more robust and error-
aware.
def divide(a, b):
if b == 0:
raise ValueError("Cannot divide by zero!")
return a / b
Summary of Exception Handling Techniques:
- Use `try`, `except` blocks to catch and handle exceptions without breaking the
program.
- Safeguard file operations to avoid file access issues.
- Handle multiple exceptions and define custom exceptions for more precise error
handling.
- Provide meaningful error messages and codes to assist developers with debugging.
- Use `finally` to ensure necessary cleanup actions, such as closing files or network
connections.
This structured approach to exception handling helps create resilient and user-friendly
programs.
Lab Assignments:
Lab Assignment 1: Scope and Nested Functions
Problem: Write a Python program demonstrating the use of global, local, and
nonlocal scopes. Also, include a nested function that modifies a variable from the
outer function using the `nonlocal` keyword.
Solution:
# Global scope
x = "global"
def outer():
# Local scope of 'outer'
x = "outer"
def inner():
nonlocal x # Refers to the 'x' in outer function
x = "inner"
print(f"Inner function scope: {x}")
inner()
print(f"Outer function scope: {x}")
outer()
print(f"Global scope: {x}")
Expected Output:
Inner function scope: inner
Outer function scope: inner
Global scope: global
Lab Assignment 2: Built-in Functions
Problem:
Use built-in functions to perform the following tasks:
1. Find the maximum and minimum of a list.
2. Sort a list in reverse order.
3. Use `map()` to square each element in a list.
Solution:
numbers = [1, 2, 3, 4, 5]
# Finding the maximum and minimum values
print(f"Max: {max(numbers)}, Min: {min(numbers)}")
# Sorting in reverse order
print(f"Sorted in reverse: {sorted(numbers, reverse=True)}")
# Using map() to square each number
squared_numbers = list(map(lambda x: x ** 2, numbers))
print(f"Squared numbers: {squared_numbers}")
**Expected Output:**
Max: 5, Min: 1
Sorted in reverse: [5, 4, 3, 2, 1]
Squared numbers: [1, 4, 9, 16, 25]
Lab Assignment 3: Decorators
Problem:
Create a decorator that adds functionality to a function by printing "Before" and
"After" the function execution.
Solution:
def my_decorator(func):
def wrapper():
print("Before the function runs")
func()
print("After the function runs")
return wrapper
@my_decorator
def greet():
print("Hello, World!")
greet()
Expected Output:
Before the function runs
Hello, World!
After the function runs
Lab Assignment 4: Generators
Problem:
Write a generator function that yields the first 5 square numbers. Also, use a generator
expression to achieve the same result.
Solution:
# Generator function
def square_numbers():
for i in range(5):
yield i ** 2
gen = square_numbers()
for num in gen:
print(num)
# Generator expression
gen_expr = (x ** 2 for x in range(5))
for num in gen_expr:
print(num)
Expected Output:
16
Lab Assignment 5: Creating and Importing Modules
Problem:
1. Create a Python module named `mymath.py` with two functions `add()` and
`multiply()`.
2. Import this module in another script and use the functions.
Solution:
mymath.py:
def add(a, b):
return a + b
def multiply(a, b):
return a * b
Main Script:
import mymath
print(mymath.add(10, 5)) # Output: 15
print(mymath.multiply(10, 5)) # Output: 50
Expected Output:
15
50
Lab Assignment 6: Exception Handling
Problem:
Write a Python program that:
1. Takes a number as input and raises a `ValueError` if the number is negative.
2. Use `try-except` to handle multiple exceptions for invalid inputs.
Solution:
def check_positive(number):
if number < 0:
raise ValueError("Number must be positive!")
try:
num = int(input("Enter a positive number: "))
check_positive(num)
print(f"Number is: {num}")
except ValueError as e:
print(f"Error: {e}")
Expected Output (for invalid input -5):
Error: Number must be positive!
