Practical Python Exercises: Master Functions and Modules

Updated: at 04:12 AM

Python is a powerful and versatile programming language used for a wide range of applications including web development, data analysis, artificial intelligence, and scientific computing. Mastering functions and modules in Python is critical for writing organized, reusable and efficient code. This guide provides a series of practical, annotated exercises to help Python developers gain proficiency in creating and using functions and modules.

Table of Contents

Open Table of Contents

Introduction

Functions and modules are essential constructs in Python that enable code modularization, abstraction, and reuse. Specifically:

Developing expertise in functions and modules is especially valuable for managing program complexity and collaboration. By mastering these concepts through hands-on exercises, Python programmers can write more powerful, extensible, and professional code.

This guide provides a curated set of practical programming exercises to build skills in:

All examples are written for Python 3 in line with PEP 8 style guidelines. Relevant language documentation is referenced throughout.

Function Exercises

Functions organize code into logical and reusable blocks. By encapsulating code in functions, developers can:

Let’s go through some key exercises to gain proficiency in Python functions.

Basic Function Definition

To define a function in Python we use the def keyword followed by the function name and parentheses () containing any parameters. The function body containing the logic is indented below.

Here is a simple function that prints a greeting:

def greet(name):
  print("Hello " + name + "!")

Let’s test it out:

>>> greet("MicroPy Beginner")
Hello MicroPy Beginner!

When we call greet() and pass the string "MicroPy Beginner", it prints the greeting message with that name.

Note: By convention, Python function names use lowercase words separated by underscores.

Return Values

Functions can process data and return a result back to the caller. This is done using the return statement.

For example, here is a function that calculates and returns the area of a circle for a given radius:

import math

def circle_area(radius):
  area = math.pi * radius**2
  return area

Let’s test it:

>>> a = circle_area(5)
>>> print(a)
78.53981633974483

Calling circle_area(5) passes 5 as the radius, calculates the area as 78.53981633974483 and assigns it to variable a.

Function Documentation

In Python, we use docstrings to document our functions. This helps provide clarity on intended usage.

Docstrings are triple-quoted string literals placed right after the function definition.

For example:

def square(num):
  """Return the square of a number."""

  return num**2

We can access docstrings using __doc__:

>>> print(square.__doc__)
Return the square of a number.

Docstrings are a best practice for function documentation in Python.

Arguments and Parameters

The terms argument and parameter have specific meanings in Python:

For example, in square(num), num is a parameter that will contain the argument passed during the function call.

Consider this increment(num) function:

def increment(num):
  return num + 1

num is the parameter that will hold the argument passed when calling increment(arg):

>>> a = 55
>>> b = increment(a)
>>> print(b)
56

Here a is the argument passed to increment() and assigned to the num parameter.

Understanding this distinction helps in designing functions and passing the expected arguments.

Default Argument Values

We can specify a default value for a function parameter by assigning it a value in the function definition. If no argument is passed for that parameter, the default is used.

For example:

def log(message, level="info"):
  print(f"{level}: {message}")

level has a default value of "info". So log("System starting") prints:

info: System starting

But we can override the default:

log("User logged in", "debug")

Prints:

debug: User logged in

Setting useful defaults allows functions to be called with fewer arguments while still being flexible.

Variable Scope

The scope of a variable is the part of the code where it is accessible. Variables defined inside a function are in the local scope and can only be used within that function.

For example:

count = 0  # global scope

def increment():
  count += 1 # increment local count

increment()
print(count)

This will print 0 - the global count variable remains unchanged. The local count is not accessible outside the function.

Global variables can be read inside functions. But best practice is to minimize use of globals.

Understanding scope helps avoid unintended overwrites of variables in different parts of the code.

Module Exercises

Modules in Python are files containing related code - such as functions and classes - that can be reused across programs. Some key module exercises are:

Using Built-in Modules

Python comes bundled with many useful built-in modules we can import. For example:

import math

print(math.pi)
print(math.sqrt(16))

This imports Python’s math module and prints pi and the square root of 16. No need to write this from scratch!

Some commonly used built-in modules include math, random, datetime, json, re, os, sys and many more. Familiarize yourself with Python’s extensive standard library.

Importing User-defined Modules

We can create our own reusable modules by simply saving Python code files with a .py extension.

For example, we can create a module calc.py:

# calc.py

def square(num):
  return num**2

def factorial(num):
  if num == 0:
    return 1
  return num * factorial(num - 1)

And import it into another program:

import calc

print(calc.square(10))
print(calc.factorial(6))

This makes those functions available for reuse.

Note we access the functions using module.function() syntax after importing.

Managing Module Namespaces

Each module has its own namespace for functions, variables, classes etc defined in it. The module name serves as identifier to avoid naming conflicts between modules.

For example:

shapes.py

def area(l, b):
  return l * b

calc.py

def area(r):
  return 3.14 * r**2

main.py

import shapes
import calc

print(shapes.area(5, 2))
print(calc.area(5))

The separate namespaces shapes and calc allow the reuse of the area function name without collision.

Namespaces prevent confusion and allow modularization into logical units.

Summary

These practical exercises help build essential Python skills in:

Mastering functions and modules will enable developing large, well-organized programs in Python.

For further learning, refer to the official Python 3 documentation on functions and modules. The functools, argparse, logging and other modules also offer many advanced usages worth exploring.

With diligent practice of these core concepts, programmers can write Python code that is extensible, professional and robust.