Python Functions: Return Values

Real-World Examples of Return Values

Let's look at some practical, real-world examples of how return values are used in different domains:

Web Development with Flask

# File: flask_example.py
# Location: /python_projects/functions_tutorial/

from flask import Flask, request, jsonify, render_template

app = Flask(__name__)

def validate_user_input(form_data):
    """
    Validate user registration data.
    
    Args:
        form_data: Dictionary of form fields
        
    Returns:
        tuple: (is_valid, errors)
            - is_valid: Boolean indicating if all data is valid
            - errors: Dictionary of field-specific error messages
    """
    errors = {}
    
    # Check username
    if not form_data.get("username"):
        errors["username"] = "Username is required"
    elif len(form_data["username"]) < 3:
        errors["username"] = "Username must be at least 3 characters"
    
    # Check email
    if not form_data.get("email"):
        errors["email"] = "Email is required"
    elif "@" not in form_data["email"] or "." not in form_data["email"]:
        errors["email"] = "Invalid email format"
    
    # Check password
    if not form_data.get("password"):
        errors["password"] = "Password is required"
    elif len(form_data["password"]) < 8:
        errors["password"] = "Password must be at least 8 characters"
    
    # Check if passwords match
    if form_data.get("password") != form_data.get("confirm_password"):
        errors["confirm_password"] = "Passwords do not match"
    
    is_valid = len(errors) == 0
    return is_valid, errors

@app.route("/register", methods=["POST"])
def register_user():
    """Handle user registration."""
    # Get form data
    form_data = request.form.to_dict()
    
    # Validate the data
    is_valid, errors = validate_user_input(form_data)
    
    if not is_valid:
        # Return the form with error messages
        return render_template("register.html", errors=errors, form_data=form_data)
    
    # Process valid registration
    # (In a real app, you would save the user to a database)
    return render_template("registration_success.html", username=form_data["username"])

@app.route("/api/register", methods=["POST"])
def api_register_user():
    """API endpoint for user registration."""
    # Get JSON data
    data = request.json
    
    # Validate the data
    is_valid, errors = validate_user_input(data)
    
    if not is_valid:
        return jsonify({"success": False, "errors": errors}), 400
    
    # Process valid registration
    # (In a real app, you would save the user to a database)
    return jsonify({"success": True, "message": "Registration successful"})

# In a real app, you would run with: app.run()

In web development, functions often return values that are used to make decisions about what response to send to the client. The separation of validation logic from request handling makes the code more modular and testable.

Data Analysis with Pandas

# File: data_analysis_example.py
# Location: /python_projects/functions_tutorial/

import pandas as pd
import numpy as np

def load_and_clean_data(file_path):
    """
    Load data from a CSV file and perform basic cleaning.
    
    Args:
        file_path: Path to the CSV file
        
    Returns:
        pandas.DataFrame: Cleaned data
    """
    # Load data (in a real app, this would read from an actual file)
    # df = pd.read_csv(file_path)
    
    # For this example, we'll create a sample DataFrame
    df = pd.DataFrame({
        'Name': ['Alice', 'Bob', 'Charlie', None, 'Eve'],
        'Age': [25, 31, 22, 28, np.nan],
        'Salary': [60000, np.nan, 55000, 70000, 65000]
    })
    
    # Clean the data
    # Remove rows with all missing values
    df = df.dropna(how='all')
    
    # Fill missing values
    df['Name'] = df['Name'].fillna('Unknown')
    df['Age'] = df['Age'].fillna(df['Age'].mean())
    df['Salary'] = df['Salary'].fillna(df['Salary'].mean())
    
    return df

def analyze_data(df):
    """
    Perform analysis on a DataFrame.
    
    Args:
        df: pandas.DataFrame containing the data
        
    Returns:
        dict: Analysis results
    """
    results = {
        'record_count': len(df),
        'age_statistics': {
            'mean': df['Age'].mean(),
            'min': df['Age'].min(),
            'max': df['Age'].max(),
            'std': df['Age'].std()
        },
        'salary_statistics': {
            'mean': df['Salary'].mean(),
            'min': df['Salary'].min(),
            'max': df['Salary'].max(),
            'std': df['Salary'].std()
        },
        'correlation': df['Age'].corr(df['Salary'])
    }
    
    return results

# Example usage
print("Loading and cleaning data...")
df = load_and_clean_data("employee_data.csv")
print(df)

print("\nAnalyzing data...")
analysis = analyze_data(df)

print("\nAnalysis Results:")
print(f"Number of records: {analysis['record_count']}")
print("\nAge Statistics:")
for key, value in analysis['age_statistics'].items():
    print(f"  {key}: {value:.2f}")
print("\nSalary Statistics:")
for key, value in analysis['salary_statistics'].items():
    print(f"  {key}: {value:.2f}")
print(f"\nCorrelation between Age and Salary: {analysis['correlation']:.2f}")

In data analysis, functions typically return processed data or analysis results. The separation of data loading, cleaning, and analysis into different functions creates a clear workflow and allows each step to be reused independently.

Game Development

# File: game_example.py
# Location: /python_projects/functions_tutorial/

import random

class Character:
    def __init__(self, name, health, attack, defense):
        self.name = name
        self.health = health
        self.max_health = health
        self.attack = attack
        self.defense = defense
    
    def __str__(self):
        return f"{self.name} (Health: {self.health}/{self.max_health})"

def create_character(character_type):
    """
    Factory function to create a character of the specified type.
    
    Args:
        character_type: The type of character to create
        
    Returns:
        Character: A new character instance
    """
    if character_type == "warrior":
        return Character("Warrior", 100, 15, 10)
    elif character_type == "mage":
        return Character("Mage", 70, 20, 5)
    elif character_type == "ranger":
        return Character("Ranger", 85, 12, 8)
    else:
        return Character("Unknown", 50, 10, 5)

def calculate_damage(attacker, defender):
    """
    Calculate damage dealt in an attack.
    
    Args:
        attacker: The attacking character
        defender: The defending character
        
    Returns:
        int: Amount of damage dealt
    """
    # Base damage is attacker's attack stat
    base_damage = attacker.attack
    
    # Add some randomness
    random_factor = random.uniform(0.8, 1.2)
    
    # Apply defense reduction
    defense_reduction = defender.defense / 30  # Convert defense to a percentage
    damage_multiplier = 1 - defense_reduction
    
    # Calculate final damage
    damage = int(base_damage * random_factor * damage_multiplier)
    
    # Ensure minimum damage of 1
    return max(1, damage)

def perform_attack(attacker, defender):
    """
    Perform an attack between characters.
    
    Args:
        attacker: The attacking character
        defender: The defending character
        
    Returns:
        tuple: (damage_dealt, is_defender_defeated)
    """
    damage = calculate_damage(attacker, defender)
    
    # Apply damage
    defender.health = max(0, defender.health - damage)
    
    # Check if defender is defeated
    is_defeated = defender.health == 0
    
    return damage, is_defeated

# Example usage in a simple battle simulation
player = create_character("warrior")
enemy = create_character("mage")

print(f"Battle begins: {player} vs {enemy}")

while player.health > 0 and enemy.health > 0:
    # Player's turn
    damage, enemy_defeated = perform_attack(player, enemy)
    print(f"{player.name} attacks for {damage} damage!")
    print(f"{enemy.name}'s health: {enemy.health}/{enemy.max_health}")
    
    if enemy_defeated:
        print(f"{enemy.name} has been defeated!")
        break
    
    # Enemy's turn
    damage, player_defeated = perform_attack(enemy, player)
    print(f"{enemy.name} attacks for {damage} damage!")
    print(f"{player.name}'s health: {player.health}/{player.max_health}")
    
    if player_defeated:
        print(f"{player.name} has been defeated!")
        break
    
    print("---")

print("Battle over!")

In game development, functions often return values that represent game state changes, calculations, or new game objects. These return values are then used to update the game state and drive the game logic.