Functions in Python
Martin Wafula
Multimedia University of Kenya
Outline 2
Introduction to Functions
Function Syntax
Parameters and Arguments
Return Values and Scope
Advanced Function Concepts
Best Practices
Practical Examples
Conclusion
Python Modules and Packages
Introduction to Functions
What Are Functions? 4
▶ A function is a reusable block of code that performs a
specific task
▶ Functions help in:
▶ Code organization and modularity
▶ Reducing code duplication
▶ Improving readability and maintainability
▶ Mathematical analogy: f(x) = x2 vs Python’s
def square(x): return x*x
Function Characteristics 5
▶ Has a name (should be descriptive and follow naming
conventions)
▶ Takes parameters (0 or more)
▶ Has a docstring (optional but recommended)
▶ Contains a body with the implementation
▶ May return a value (or None if no return statement)
Function Syntax
Function Definition 7
Basic Syntax
def function_name(parameters):
"""docstring - describes what the function does"""
# Function body
# ...
return value # optional
Example
def greet(name):
"""Prints a greeting message"""
print(f"Hello, {name}!")
return len(name) # returns length of name
Function Invocation 8
Calling a Function
result = function_name(arguments)
Example
>>> message_length = greet("Alice")
Hello, Alice!
>>> print(message_length)
5
Parameters and Arguments
Parameters vs. Arguments 10
▶ Parameters: Variables in the function definition
▶ Arguments: Actual values passed to the function
▶ Python supports several argument types:
▶ Positional arguments: most basic types of arguments.
They are passed in order to the function and match the
function parameters.
▶ Keyword arguments: Are passed using parameter names
rather than position. Order doesn’t matter.
▶ Default arguments: Have a default value if no value is
provided. They must come after required (non-default)
parameters.
▶ Variable-length arguments (*args and **kwargs):
We use them when we do not know the number of
arguments
Positional vs Keyword Arguments 11
Positional
def describe_pet(animal, name):
print(f"I have a {animal} named {name}")
describe_pet("dog", "Rex")
Keyword
def describe_pet(animal, name):
print(f"I have a {animal} named {name}")
describe_pet(name="Rex", animal="dog")
Default Arguments 12
Function Definition
def describe_pet(name, animal="dog"):
print(f"I have a {animal} named {name}")
Function Calls
describe_pet("Rex") # Uses default
describe_pet("Fluffy", "cat") # Overrides default
Variable-Length Arguments 13
*args (allows function to accept any number of positional
arguments. Inside function, args is a tuple)
def average(*numbers):
return sum(numbers)/len(numbers)
print(average(1, 2, 3)) # 2.0
**kwargs (allows a function accept any number of key
arguments or named arguments. kwargs is a dictionary.)
def person_info(**details):
for key, value in details.items():
print(f"{key}: {value}")
person_info(name="Alice", age=25, city = "London")
Differences between *args and **kwargs 14
Feature *args **kwargs
Type Tuple Dictionary
Usage Collects positional arguments Collects keyword arg
Example call func(1, 2, 3) func(a = 1, b =
Unpacking *args unpacks a tuple/ list **kwargs unpacks a d
Return Values and Scope
Return Statement 16
▶ The return statement exits the function and optionally
returns a value
▶ Functions without return return None
▶ Multiple values can be returned as a tuple
Example
def min_max(numbers):
return min(numbers), max(numbers)
low, high = min_max([3, 1, 4, 1, 5, 9])
Variable Scope 17
▶ Local variables: Defined in a function, only accessible
within it
▶ Global variables: Defined outside functions, accessible
throughout
▶ The global keyword allows modifying global variables
inside functions
Example
def increment():
global count
count += 1
Advanced Function Concepts
Lambda Functions 19
▶ Anonymous functions defined with lambda
▶ Typically used for short, simple operations
▶ Syntax: lambda parameters: expression
Example
square = lambda x: x * x
sorted_names = sorted(names, key=lambda x: x.lower())
Function Decorators 20
▶ Functions that modify the behavior of other functions
▶ Useful for adding functionality without changing the
original code
Example
def timer(func):
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
print(f"Time: {time.time()-start}")
return result
return wrapper
@timer
def compute():
# Long computation
Recursion 21
▶ A function that calls itself
▶ Must have a base case to prevent infinite recursion
Example
def factorial(n):
if n == 0: # Base case
return 1
return n * factorial(n-1)
Best Practices
Function Design Guidelines 23
▶ Single Responsibility Principle: Each function should
do one thing
▶ Use descriptive names (verbs for actions, nouns for data)
▶ Limit parameters (3-4 max)
▶ Use default arguments for common cases
▶ Document with docstrings
▶ Avoid modifying mutable arguments unless intended
▶ Prefer returning values over modifying globals
Effective Docstrings 24
Good Documentation
def calculate_area(length, width):
"""
Calculate the area of a rectangle.
Args:
length (float): The length of the rectangle
width (float): The width of the rectangle
Returns:
float: The area of the rectangle
Raises:
ValueError: If either dimension is negative
"""
if length < 0 or width < 0:
raise ValueError("Dimensions must be positive")
return length * width
Practical Examples
Example 1: Temperature Conversion 26
def celsius_to_fahrenheit(celsius):
"""Convert Celsius to Fahrenheit"""
return (celsius * 9/5) + 32
def fahrenheit_to_celsius(fahrenheit):
"""Convert Fahrenheit to Celsius"""
return (fahrenheit - 32) * 5/9
# Usage
print(f"32°F = {fahrenheit_to_celsius(32):.1f}°C")
print(f"100°C = {celsius_to_fahrenheit(100):.1f}°F")
Example 2: Password Generator 27
import random
import string
def generate_password(length=12, use_special=True):
"""
Generate a random password.
Args:
length (int): Length of password (default 12)
use_special (bool): Include special chars (default
Returns:
str: Generated password
"""
chars = string.ascii_letters + string.digits
if use_special:
chars += string.punctuation
return ''.join(random.choice(chars) for _ in range(leng
Conclusion
Summary 29
▶ Functions are essential for modular, reusable code
▶ Python offers flexible parameter/argument handling
▶ Proper scoping and return values are crucial
▶ Advanced features like lambdas and decorators add power
▶ Following best practices leads to maintainable code
Next Steps 30
▶ Practice writing various functions
▶ Explore Python’s built-in functions
▶ Learn about generator functions and closures
▶ Study function annotations (type hints)
▶ Experiment with decorators
Python Modules and Packages
Understanding Python’s Import System 32
▶ Python’s import system is powerful and flexible
▶ Based on the concept of a module search path
▶ Key components:
▶ sys.path - List of directories Python searches for modules
▶ __import__() - Built-in function that does the actual
importing
▶ Module cache (sys.modules) - Stores already imported
modules
▶ Import process:
1. Check if module is already in sys.modules
2. Search through sys.path for the module
3. Compile and execute the module (storing in sys.modules)
The Module Search Path 33
Viewing sys.path
import sys
print(sys.path)
Typical search order:
1. Directory containing the input script (or current directory)
2. PYTHONPATH environment variable directories
3. Installation-dependent default path
▶ Site-packages directory for installed packages
Modifying the search path
import sys
sys.path.append('/path/to/my/modules')
Detailed Import Mechanisms 34
Absolute Imports
from package.subpackage import module
from package.subpackage.module import function
Relative Imports (within a package)
from . import module # Current package
from .. import module # Parent package
from ..subpackage import module
Import Best Practices
▶ Prefer absolute imports for readability
▶ Use relative imports only within packages
▶ Avoid circular imports
Module Execution and Namespace 35
▶ When imported, module code is executed once
▶ Creates a module object with its own namespace
▶ __name__ attribute:
▶ "__main__" when run directly
▶ Module name when imported
Module namespace example (module.py)
"""Module documentation"""
import sys
def func():
pass
class MyClass:
pass
print(f"Namespace: {dir()}")
print(f"Name: {__name__}")
Package Initialization 36
▶ __init__.py files:
▶ Make directories recognizable as packages
▶ Can be empty or contain initialization code
▶ Executed when package is imported
▶ Can define __all__ to control from package import *
Example __init__.py
"""Package documentation"""
from .module1 import func1
from .module2 import func2
__all__ = ['func1', 'func2'] # What gets imported with *
# Package-level initialization
print(f"Initializing {__name__}")
Advanced Import Features 37
Dynamic Imports
# Using __import__()
module_name = "math"
math = __import__(module_name)
print(math.sqrt(16))
# Using importlib
import importlib
math = importlib.import_module("math")
Import Hooks
▶ Customize import behavior
▶ Implement importlib.abc.MetaPathFinder or
importlib.abc.PathEntryFinder
▶ Used by tools like pytest, Django
Python’s Import Cache 38
▶ sys.modules acts as a cache
▶ Already imported modules are stored here
▶ Can be manipulated (with caution)
Working with sys.modules
import sys
import math
print('math' in sys.modules) # True
# Force reload
del sys.modules['math']
import math # Module is reloaded
Warning
Modifying sys.modules can lead to subtle bugs. Use
importlib.reload() instead.
Module Attributes 39
Attribute Purpose
__name__ Module name
__file__ Path to module file
__package__ Package name
__doc__ Module docstring
__annotations__ Variable annotations
__dict__ Module namespace
Inspecting a module
import math
print(math.__name__) # 'math'
print(math.__file__) # Path to math.py
print(math.__doc__) # Documentation
Common Import Patterns 40
Lazy Import Pattern
▶ Delay imports until needed
▶ Useful for optional dependencies
Interface Pattern
▶ Use __init__.py to expose clean API
▶ Hide implementation details
Plugin Pattern
▶ Dynamically discover and load modules
▶ Using importlib or pkgutil
Import Gotchas 41
Circular Imports
# module_a.py
import module_b
def func_a():
module_b.func_b()
# module_b.py
import module_a
def func_b():
module_a.func_a()
Solutions
▶ Restructure code to remove circularity
▶ Move imports inside functions
▶ Use import at module level only
Python’s Module Types 42
▶ Pure Python modules (.py files)
▶ Compiled modules (.pyc files)
▶ Built-in modules (written in C, compiled into
interpreter)
▶ Frozen modules (embedded in custom Python binaries)
▶ Namespace packages (PEP 420, no __init__.py)
Checking module type
import math
import mymodule
print(type(math)) # <class 'module'>
print(math.__file__) # Shows if it's .py or built-in
Working with Packages 43
Package Structure
my_package/
__init__.py # Package initialization
module1.py # Regular module
subpackage/
__init__.py # Subpackage initialization
module2.py
data/
file.txt # Package data files
Accessing Package Data
from importlib.resources import files
data = files('my_package.data').joinpath('file.txt')
Modern Python Packaging 44
pyproject.toml (PEP 517/518)
[build-system]
requires = ["setuptools>=42"]
build-backend = "setuptools.build_meta"
[project]
name = "my_package"
version = "1.0.0"
dependencies = [
"requests>=2.25.0",
"numpy>=1.20.0"
]
▶ setuptools: Traditional packaging
▶ poetry: Modern dependency management
▶ pipenv: Combines pip and virtualenv
Package Distribution 45
▶ PyPI (Python Package Index): Main repository
▶ TestPyPI: For testing package uploads
▶ Distribution formats:
▶ Source distribution (.tar.gz)
▶ Wheel (.whl) - Built distribution
▶ Tools:
▶ twine: Secure package uploads
▶ build: Create distribution packages
Publishing a Package
1. Create pyproject.toml
2. Build distributions: python -m build
3. Upload: twine upload dist/*
Questions 46
Any questions?
