Functions and Modules

Functions and modules are essential components of Python that allow for code reuse, organization, and modularity. This chapter covers defining functions, lambda functions, and using modules and packages.

def function_name(parameters):
    # Code block

def greet_customer():
    print("Welcome to our store!")

greet_customer()

def get_customer_discount(name, purchase_amount):
    if purchase_amount > 100:
        discount = 10
    else:
        discount = 5
    return f"{name} gets a {discount}% discount."

def thank_customer(name="Customer"):
    print(f"Thank you, {name}, for your purchase!")

thank_customer("John")
thank_customer()

def update_customer_info(name, email, phone):
    print(f"Updating info: Name={name}, Email={email}, Phone={phone}")

update_customer_info("Emma", "emma@example.com", "1234567890")

update_customer_info(name="John", phone="0987654321", email="John@example.com")

def send_promotions(customers):
    for customer in customers:
        print(f"Sending promo to {customer}")

customer_list = ["Anna", "Brian", "Clara"]
send_promotions(customer_list)

def get_vip_customers(customers):
    return [c for c in customers if c['purchase_total'] > 1000]

customers = [
    {"name": "Sam", "purchase_total": 500},
    {"name": "Nina", "purchase_total": 1200},
]
print(get_vip_customers(customers))

global_discount = 5  # Global

def calculate_final_price(purchase_amount):
    local_discount = 10  # Local
    return purchase_amount * (1 - local_discount / 100)

print(calculate_final_price(200))
print(global_discount)
# print(local_discount)  # Error: not defined outside function

def delete_customer_record(customer_id):
    # Logic to be implemented later
    pass

def count_customers(customers):
    if not customers:
        return 0
    return 1 + count_customers(customers[1:])

customer_names = ["Ava", "Ben", "Cara", "Dan"]
print(count_customers(customer_names))  # Output: 4

Lambda Functions

Introduction to Lambda Functions

A lambda function is a small, anonymous function that can have multiple arguments but only one expression.

square = lambda x: x ** 2
print("Square of 5:", square(5))
    

Using map(), filter(), and reduce()

Using map():

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print("Squared List:", squared)
    

Using filter():

evens = list(filter(lambda x: x % 2 == 0, numbers))
print("Even Numbers:", evens)
    

Using reduce():

from functools import reduce
product = reduce(lambda x, y: x * y, numbers)
print("Product of List:", product)
    

Modules and Packages

In Python, modules and packages help organize and structure code efficiently, making it reusable and maintainable.

What is a Module?

A module is a Python file (.py) that contains functions, classes, and variables that can be imported into other Python scripts.

Importing Modules

Python has many built-in modules that can be imported using the import keyword.

import math
print("Square root of 25:", math.sqrt(25))
    

You can also use from module import function:

from math import sqrt
print("Square root of 36:", sqrt(36))
    

Creating Custom Modules

A module is a .py file containing functions and variables that can be imported into other scripts.

Step 1: Create a custom module (mymodule.py)

# mymodule.py
def greet(name):
    return f"Hello, {name}!"

PI = 3.1416
    

Step 2: Import and use the custom module

import mymodule

print(mymodule.greet("Alice"))
print("Value of PI:", mymodule.PI)
    

What is a Package?

A package is a collection of modules stored in a directory. Packages help organize large codebases into structured components.

Understanding Packages and Structures

A package is a collection of modules organized in directories. A package must contain an __init__.py file to be recognized as a package.

Example Package Structure

mypackage/
│── __init__.py
│── module1.py
│── module2.py
    

module1.py

def hello():
    return "Hello from module1!"
    

module2.py

def add(a, b):
    return a + b
    

Importing from a Package

from mypackage import module1, module2

print(module1.hello())
print("Sum:", module2.add(10, 20))
    

Summary

• Functions allow for code reuse and organization.
• Lambda functions are concise anonymous functions used with map(), filter(), and reduce().
• Modules allow for better organization by separating functionality into different files.
• Packages help structure larger projects into multiple modules.

✅ Project: Supply Chain Inventory Program

Inventory Tracking - Supply Chain Management System Using Functions:

This project demonstrates a basic inventory tracking function, useful in a customer supply chain management system. The function updates stock levels based on incoming and outgoing orders.

📦 Python Code Example

# Supply chain inventory tracking

inventory = {
    "Widget-A": 100,
    "Widget-B": 50,
    "Gadget-X": 75
}

def update_inventory(product, quantity, operation):
    if product not in inventory:
        return f"{product} not found."

    if operation == "in":
        inventory[product] += quantity
        return f"{quantity} added to {product}. New total: {inventory[product]}"
    
    elif operation == "out":
        if quantity > inventory[product]:
            return f"Not enough {product} in stock."
        inventory[product] -= quantity
        return f"{quantity} removed from {product}. New total: {inventory[product]}"
    
    else:
        return "Invalid operation. Use 'in' or 'out'."

def show_inventory():
    print("\nCurrent Inventory:")
    print("------------------")
    for item, count in inventory.items():
        print(f"{item}: {count} units")
    print()

# Example usage
print(update_inventory("Widget-A", 20, "in"))
print(update_inventory("Widget-A", 10, "out"))
print(update_inventory("Gadget-X", 100, "out"))

show_inventory()
    

🖨️ Sample Output

20 added to Widget-A. New total: 120
10 removed from Widget-A. New total: 110
Not enough Gadget-X in stock.

Current Inventory:
------------------
Widget-A: 110 units
Widget-B: 50 units
Gadget-X: 75 units