Python returnとは？関数から値を返す基本的な方法

関数から値を取り出したいと思いませんか？

みなさん、Pythonで関数を作った時に「計算結果を呼び出し元に渡したい」と思ったことはありませんか？

「関数で計算したけど、どうやって結果を使うの？」 「print文じゃだめなの？」 「returnって何をするもの？」

このような疑問を持ったことはありませんか？

実は、return文を使うことで、関数から値を取り出して他の処理で活用できるようになるんです。

この記事では、Python初心者の方に向けて、return文の基本的な使い方から実践的な活用方法まで詳しく解説します。 関数から値を適切に返す方法をマスターして、より実用的なプログラムを作りましょう！

return文って何？

まず、return文の基本的な概念を理解しましょう。

これを知ると、なぜ関数が便利なのかがわかります。

return文の役割

return文は関数の「答え」を返すもの

return文は、関数の実行を終了し、指定した値を呼び出し元に返すためのキーワードです。

関数が「答え」を返すための仕組みと考えると分かりやすいですね。

# 基本的なreturn文の例
def add_numbers(a, b):
    result = a + b
    return result  # 計算結果を返す

# 関数の呼び出しと結果の受け取り
answer = add_numbers(5, 3)
print(answer)  # 8

このコードでは、add_numbers関数が5と3を足した結果の8を返しています。

answerという変数に関数の結果が保存され、後で使うことができます。

実行結果：

8

計算結果を他の処理で使えるようになるのが、return文の大きなメリットです。

より簡潔な書き方もできます

# より簡潔な書き方
def multiply(a, b):
    return a * b  # 直接計算結果を返す

product = multiply(4, 7)
print(product)  # 28

計算結果を直接returnすることで、コードがすっきりします。

実行結果：

28

return文により、関数は単なる処理の実行だけでなく、結果の受け渡しが可能になります。

return文がない場合はどうなる？

return文を書かない関数は、自動的にNoneを返します

# return文がない関数
def greet(name):
    print(f"こんにちは、{name}さん")
    # return文がない

# 戻り値を確認
result = greet("田中")
print(f"戻り値: {result}")  # 戻り値: None

この関数はprintで表示はしますが、戻り値はNoneになります。

実行結果：

こんにちは、田中さん 戻り値: None

**Noneは「何もない」**という意味の特別な値です。

print文とreturn文の違い

print文は表示するだけ、return文は値を返す

# print文とreturn文の違い
def print_sum(a, b):
    print(a + b)  # 画面に表示するだけ

def return_sum(a, b):
    return a + b  # 値を返す

# 使い方の違い
print_sum(3, 4)        # 7（画面に表示）
result1 = print_sum(3, 4)  # result1にはNoneが入る

result2 = return_sum(3, 4)  # result2には7が入る
print(result2 * 2)     # 14（計算に使用可能）

print文は表示するだけですが、return文は値を返すので後続の処理で使用できます。

実行結果：

7 14

return文を使うことで、関数の結果を他の計算に活用できるようになります。

基本的なreturn文の使い方

レベル別にreturn文の使い方を見ていきましょう。

単一の値を返すパターン

最も基本的なパターンは、一つの値を返すことです。

どのデータ型でも返すことができるのがPythonの柔軟性です。

# 数値を返す
def calculate_area(width, height):
    area = width * height
    return area

# 文字列を返す
def create_greeting(name):
    greeting = f"おはようございます、{name}さん"
    return greeting

# ブール値を返す
def is_even(number):
    return number % 2 == 0

# リストを返す
def create_number_list(start, end):
    numbers = []
    for i in range(start, end + 1):
        numbers.append(i)
    return numbers

それぞれの関数を使ってみましょう。

# 使用例
room_area = calculate_area(6, 8)
print(f"部屋の面積: {room_area}平方メートル")

morning_msg = create_greeting("佐藤")
print(morning_msg)

print(f"4は偶数？ {is_even(4)}")  # True
print(f"7は偶数？ {is_even(7)}")  # False

numbers = create_number_list(1, 5)
print(f"数列: {numbers}")  # [1, 2, 3, 4, 5]

実行結果：

部屋の面積: 48平方メートル おはようございます、佐藤さん 4は偶数？ True 7は偶数？ False 数列: [1, 2, 3, 4, 5]

どのデータ型でも返せるので、用途に応じて適切な値を返しましょう。

条件によって異なる値を返す

条件分岐を使って、状況に応じて異なる値を返すパターンです。

# 成績評価関数
def get_grade(score):
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

この関数は点数に応じて適切な成績を返します。

条件を満たした時点ですぐに関数が終了するのが特徴です。

# 年齢区分判定
def get_age_category(age):
    if age < 0:
        return "無効な年齢"
    elif age < 13:
        return "子ども"
    elif age < 20:
        return "青少年"
    elif age < 65:
        return "成人"
    else:
        return "高齢者"

エラーケースも含めて適切に判定できます。

# 使用例
print(f"85点の成績: {get_grade(85)}")  # B
print(f"25歳の区分: {get_age_category(25)}")  # 成人

実行結果：

85点の成績: B 25歳の区分: 成人

条件分岐により、関数の柔軟性が大幅に向上します。

早期リターン（Early Return）

条件を満たした時点で即座に関数を終了するパターンです。

# ユーザー認証関数
def authenticate_user(username, password, is_active):
    # 入力値の検証
    if not username:
        return {"success": False, "message": "ユーザー名が入力されていません"}
    
    if not password:
        return {"success": False, "message": "パスワードが入力されていません"}
    
    # アカウント状態の確認
    if not is_active:
        return {"success": False, "message": "アカウントが無効化されています"}
    
    # 認証処理（簡略化）
    if username == "admin" and password == "secret123":
        return {"success": True, "message": "認証成功", "role": "admin"}
    elif username == "user" and password == "password":
        return {"success": True, "message": "認証成功", "role": "user"}
    else:
        return {"success": False, "message": "ユーザー名またはパスワードが間違っています"}

問題があった時点ですぐに終了することで、複雑な条件分岐を避けられます。

# 素数判定関数
def is_prime(number):
    # 特別なケース
    if number < 2:
        return False
    
    if number == 2:
        return True
    
    if number % 2 == 0:
        return False
    
    # 奇数の約数をチェック
    for i in range(3, int(number ** 0.5) + 1, 2):
        if number % i == 0:
            return False
    
    return True

段階的にチェックすることで、効率的な判定ができます。

# 使用例
auth_result = authenticate_user("admin", "secret123", True)
print(f"認証結果: {auth_result}")

print(f"17は素数？ {is_prime(17)}")  # True
print(f"15は素数？ {is_prime(15)}")  # False

実行結果：

認証結果: {'success': True, 'message': '認証成功', 'role': 'admin'} 17は素数？ True 15は素数？ False

早期リターンにより、複雑な条件分岐を整理できます。

複数の値を返すテクニック

Pythonでは、複数の値を同時に返すことができます。

これを知ると、関数がさらに便利になります。

タプルで複数値を返す

Pythonでは、複数の値を同時に返すことができます

# 複数の値を返す基本例
def get_name_age():
    return "田中太郎", 25

# 複数の値を受け取る
name, age = get_name_age()
print(f"名前: {name}, 年齢: {age}")

カンマで区切るだけで、複数の値を返せます。

実行結果：

名前: 田中太郎, 年齢: 25

同時に複数の変数に代入できるのが便利です。

統計値を計算する関数

# 統計値を計算する関数
def calculate_statistics(numbers):
    if not numbers:
        return 0, 0, 0, 0  # 合計, 平均, 最大, 最小
    
    total = sum(numbers)
    average = total / len(numbers)
    maximum = max(numbers)
    minimum = min(numbers)
    
    return total, average, maximum, minimum

# 使用例
scores = [85, 92, 78, 90, 88]
total, avg, max_val, min_val = calculate_statistics(scores)

print(f"合計: {total}")
print(f"平均: {avg:.1f}")
print(f"最高: {max_val}")
print(f"最低: {min_val}")

一度の関数呼び出しで複数の統計値を取得できます。

実行結果：

合計: 433 平均: 86.6 最高: 92 最低: 78

タプルアンパッキングにより、複数の値を効率的に扱えるようになります。

座標計算の例

# 座標計算
def calculate_circle_properties(radius):
    import math
    
    circumference = 2 * math.pi * radius
    area = math.pi * radius ** 2
    
    return circumference, area

perimeter, circle_area = calculate_circle_properties(5)
print(f"円周: {perimeter:.2f}, 面積: {circle_area:.2f}")

関連する複数の計算結果を一度に返せます。

実行結果：

円周: 31.42, 面積: 78.54

複数の値を返すことで、関数の利便性が向上します。

辞書で構造化されたデータを返す

より複雑なデータは辞書で返すと管理しやすくなります。

# ユーザー情報を取得する関数
def get_user_profile(user_id):
    # 実際のデータベースから取得する処理の代わり
    user_data = {
        1001: {"name": "田中太郎", "email": "tanaka@example.com", "age": 28},
        1002: {"name": "佐藤花子", "email": "sato@example.com", "age": 32}
    }
    
    if user_id not in user_data:
        return {
            "found": False,
            "message": "ユーザーが見つかりません"
        }
    
    user = user_data[user_id]
    return {
        "found": True,
        "user_id": user_id,
        "name": user["name"],
        "email": user["email"],
        "age": user["age"],
        "is_adult": user["age"] >= 18
    }

条件に応じて異なる構造の辞書を返すことができます。

# 使用例
profile = get_user_profile(1001)
if profile["found"]:
    print(f"ユーザー: {profile['name']} ({profile['age']}歳)")
    print(f"メール: {profile['email']}")
else:
    print(profile["message"])

実行結果：

ユーザー: 田中太郎 (28歳) メール: tanaka@example.com

辞書を返すことで、関連する複数の情報を構造化して扱えるようになります。

Noneを返すパターン

処理が完了したが返す値がない場合や、エラー状態を表現する場合について学びましょう。

意図的にNoneを返す場合

処理が完了したが返す値がない場合に使います。

# 設定を更新する関数（戻り値なし）
def update_user_settings(user_id, settings):
    print(f"ユーザー{user_id}の設定を更新中...")
    
    # 設定更新処理（実際にはデータベース更新など）
    for key, value in settings.items():
        print(f"  {key}: {value}")
    
    print("設定更新完了")
    return None  # 明示的にNoneを返す（省略可能）

処理は成功したが、特に返す値がない場合にNoneを返します。

# 検索結果がない場合
def find_user_by_email(email):
    users = [
        {"id": 1, "name": "田中", "email": "tanaka@example.com"},
        {"id": 2, "name": "佐藤", "email": "sato@example.com"}
    ]
    
    for user in users:
        if user["email"] == email:
            return user
    
    # 見つからない場合はNoneが返される（return文なし）

検索で見つからない場合も、Noneが返されます。

# 使用例
update_user_settings(1001, {"theme": "dark", "language": "ja"})

user = find_user_by_email("tanaka@example.com")
if user:
    print(f"ユーザー発見: {user['name']}")
else:
    print("ユーザーが見つかりません")

実行結果：

ユーザー1001の設定を更新中... theme: dark language: ja 設定更新完了 ユーザー発見: 田中

Noneを返すことで、「値がない」状態を明確に表現できます。

エラー処理でのNone活用

# エラー処理でNoneを返す
def safe_divide(a, b):
    if b == 0:
        print("エラー: ゼロで割ることはできません")
        return None
    
    return a / b

# 使用例
result = safe_divide(10, 0)
if result is not None:
    print(f"計算結果: {result}")
else:
    print("計算に失敗しました")

エラーが発生した場合にNoneを返すことで、安全な処理ができます。

実行結果：

エラー: ゼロで割ることはできません 計算に失敗しました

Noneチェックにより、エラーを適切に処理できます。

実践的なreturn活用例

実用的な関数でのreturn活用を見ていきましょう。

データ処理関数

実用的なデータ処理でのreturn活用例です。

def process_sales_data(sales_records):
    """売上データを処理して分析結果を返す"""
    
    if not sales_records:
        return {"error": "売上データがありません"}
    
    # データの前処理
    valid_records = []
    for record in sales_records:
        if (record.get("amount", 0) > 0 and 
            record.get("date") and 
            record.get("product")):
            valid_records.append(record)
    
    if not valid_records:
        return {"error": "有効な売上データがありません"}
    
    # 分析処理
    total_sales = sum(record["amount"] for record in valid_records)
    product_sales = {}
    
    for record in valid_records:
        product = record["product"]
        amount = record["amount"]
        
        # 商品別売上
        product_sales[product] = product_sales.get(product, 0) + amount
    
    # 上位商品の特定
    top_products = sorted(
        product_sales.items(), 
        key=lambda x: x[1], 
        reverse=True
    )[:3]
    
    return {
        "summary": {
            "total_sales": total_sales,
            "total_records": len(valid_records),
            "average_per_sale": round(total_sales / len(valid_records), 2)
        },
        "top_products": top_products,
        "analysis_date": "2024-07-07"
    }

複雑なデータ処理の結果を構造化して返すことで、呼び出し元で活用しやすくなります。

# 使用例
sales_data = [
    {"date": "2024-01-15", "product": "ノートPC", "amount": 80000},
    {"date": "2024-01-20", "product": "マウス", "amount": 2000},
    {"date": "2024-02-05", "product": "ノートPC", "amount": 80000},
    {"date": "2024-02-10", "product": "キーボード", "amount": 5000}
]

analysis = process_sales_data(sales_data)
if "error" not in analysis:
    print("=== 売上分析結果 ===")
    print(f"総売上: {analysis['summary']['total_sales']:,}円")
    print(f"平均売上: {analysis['summary']['average_per_sale']:,}円")
    print("上位商品:")
    for product, amount in analysis["top_products"]:
        print(f"  {product}: {amount:,}円")

実行結果：

=== 売上分析結果 === 総売上: 167,000円 平均売上: 41,750円 上位商品: ノートPC: 160,000円 キーボード: 5,000円 マウス: 2,000円

実用的な関数では、エラーハンドリングと結果の構造化が重要になります。

バリデーション関数

データの検証でのreturn活用例です。

def validate_user_registration(user_data):
    """ユーザー登録データの検証"""
    
    errors = []
    
    # 必須フィールドのチェック
    required_fields = ["username", "email", "password", "age"]
    for field in required_fields:
        if field not in user_data or not user_data[field]:
            errors.append(f"{field}は必須項目です")
    
    # 早期リターン（必須フィールドが不足している場合）
    if errors:
        return {
            "valid": False,
            "errors": errors,
            "message": "必須項目が不足しています"
        }
    
    # 個別のバリデーション
    username = user_data["username"]
    email = user_data["email"]
    password = user_data["password"]
    age = user_data["age"]
    
    # ユーザー名の検証
    if len(username) < 3 or len(username) > 20:
        errors.append("ユーザー名は3文字以上20文字以下である必要があります")
    
    # メールアドレスの検証
    if "@" not in email or "." not in email.split("@")[-1]:
        errors.append("有効なメールアドレスを入力してください")
    
    # パスワードの検証
    if len(password) < 8:
        errors.append("パスワードは8文字以上である必要があります")
    
    # 年齢の検証
    try:
        age_int = int(age)
        if age_int < 13 or age_int > 120:
            errors.append("年齢は13歳以上120歳以下である必要があります")
    except ValueError:
        errors.append("年齢は数値で入力してください")
    
    # 結果の返却
    if errors:
        return {
            "valid": False,
            "errors": errors,
            "message": f"{len(errors)}個の検証エラーがあります"
        }
    else:
        return {
            "valid": True,
            "message": "検証に成功しました",
            "validated_data": {
                "username": username.lower(),
                "email": email.lower(),
                "age": int(age)
            }
        }

バリデーション結果を詳細に返すことで、呼び出し元で適切な処理ができます。

# 使用例
test_data = {
    "username": "TestUser123",
    "email": "test@example.com",
    "password": "SecurePass123",
    "age": "25"
}

validation_result = validate_user_registration(test_data)

if validation_result["valid"]:
    print("✅ 検証成功")
    print(f"検証済みデータ: {validation_result['validated_data']}")
else:
    print("❌ 検証失敗")
    print(f"メッセージ: {validation_result['message']}")
    for error in validation_result["errors"]:
        print(f"  - {error}")

実行結果：

✅ 検証成功 検証済みデータ: {'username': 'testuser123', 'email': 'test@example.com', 'age': 25}

バリデーション関数では、詳細なエラー情報と成功時のデータを適切に返すことが重要です。

まとめ: return文で関数を活用しよう

Python return文の重要なポイントをまとめます。

重要なポイント

基本概念

• 関数から値を呼び出し元に返す
• 関数の実行を終了する
• return文がない場合はNoneが返される

基本的な使い方

• 単一の値を返す
• 条件によって異なる値を返す
• 早期リターンで処理を効率化

複数値の返却

• タプルで複数の値を同時に返す
• 辞書で構造化されたデータを返す
• アンパッキングで複数の値を受け取る

Noneの活用

• 処理完了だが返す値がない場合
• エラーや例外状態の表現
• 検索結果がない場合の表現

実践的な活用

• データ処理と分析結果の返却
• エラーハンドリングとメッセージ
• バリデーション結果の構造化

設計のポイント

• 戻り値の型を一貫させる
• エラー情報を含む構造化されたデータ
• 早期リターンで読みやすいコード

return文は、関数を実用的で再利用可能にするための重要な機能です。

適切に値を返すことで、関数同士を組み合わせた複雑なプログラムが作成できるようになります。

ぜひ、様々なパターンでreturn文を活用して、効果的な関数設計スキルを身につけてくださいね！