Pythonにおけるユーザー定義関数作成の基本と応用10選

def 関数名(引数1, 引数2, ...):
    # 処理内容
    return 戻り値

def add_numbers(a, b):
    result = a + b
    return result

# 関数を使ってみる
sum = add_numbers(5, 3)
print(sum)  # 8が出力されます

def greet(name="ゲスト"):
    return f"こんにちは、{name}さん！"

print(greet())  # こんにちは、ゲストさん！
print(greet("太郎"))  # こんにちは、太郎さん！

def divide_and_remainder(a, b):
    quotient = a // b
    remainder = a % b
    return quotient, remainder

result = divide_and_remainder(17, 5)
print(result)  # (3, 2)が出力されます

def calculate_bmi(weight, height):
    # 身長をメートルに変換
    height_m = height / 100
    # BMIの計算
    bmi = weight / (height_m ** 2)
    # 小数点第2位まで丸める
    return round(bmi, 2)

# 関数を使ってみる
weight = 70  # kg
height = 175  # cm
bmi = calculate_bmi(weight, height)
print(f"あなたのBMIは{bmi}です。")

class Car:
    def __init__(self, brand, model, year):
        self.brand = brand
        self.model = model
        self.year = year
        self.speed = 0

    def accelerate(self, amount):
        self.speed += amount
        return f"{self.brand} {self.model}の速度が{amount}km/h上がりました。現在の速度は{self.speed}km/hです。"

    def brake(self, amount):
        if self.speed - amount < 0:
            self.speed = 0
        else:
            self.speed -= amount
        return f"{self.brand} {self.model}の速度が{amount}km/h下がりました。現在の速度は{self.speed}km/hです。"

# クラスを使ってみる
my_car = Car("Toyota", "Corolla", 2022)
print(my_car.accelerate(30))
print(my_car.accelerate(20))
print(my_car.brake(15))

Toyota Corollaの速度が30km/h上がりました。現在の速度は30km/hです。
Toyota Corollaの速度が20km/h上がりました。現在の速度は50km/hです。
Toyota Corollaの速度が15km/h下がりました。現在の速度は35km/hです。

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount
        return f"{amount}円を預け入れました。残高は{self.balance}円です。"

    def withdraw(self, amount):
        if self.balance >= amount:
            self.balance -= amount
            return f"{amount}円を引き出しました。残高は{self.balance}円です。"
        else:
            return "残高が足りません。"

    def get_balance(self):
        return f"{self.owner}様の残高は{self.balance}円です。"

# クラスを使ってみる
account = BankAccount("山田太郎", 10000)
print(account.get_balance())
print(account.deposit(5000))
print(account.withdraw(2000))
print(account.withdraw(15000))

山田太郎様の残高は10000円です。
5000円を預け入れました。残高は15000円です。
2000円を引き出しました。残高は13000円です。
残高が足りません。

def power_function(n):
    def power(x):
        return x ** n
    return power

# 2乗する関数
square = power_function(2)
# 3乗する関数
cube = power_function(3)

print(square(4))  # 16
print(cube(4))    # 64

# 通常の関数定義
def add(x, y):
    return x + y

# lambda式を使った定義
add_lambda = lambda x, y: x + y

print(add(3, 4))       # 7
print(add_lambda(3, 4))  # 7

# リスト内の各要素に対して操作を行う
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

import time

def timing_decorator(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__}の実行時間: {end - start:.4f}秒")
        return result
    return wrapper

@timing_decorator
def slow_function():
    time.sleep(2)
    print("処理が完了しました")

slow_function()

処理が完了しました
slow_functionの実行時間: 2.0021秒

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n-1)

print(factorial(5))  # 120

global_var = "私はグローバル変数です"

def function_scope():
    local_var = "私はローカル変数です"
    print(global_var)  # グローバル変数にアクセス可能
    print(local_var)   # ローカル変数にアクセス可能

function_scope()
print(global_var)  # グローバル変数にアクセス可能
# print(local_var)  # エラー：ローカル変数にはアクセス不可

counter = 0

def increment():
    global counter
    counter += 1
    print(f"カウンター: {counter}")

increment()  # カウンター: 1
increment()  # カウンター: 2

def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("エラー: ゼロで割ることはできません")
        return None
    except TypeError:
        print("エラー: 数値を入力してください")
        return None
    else:
        return result

print(divide(10, 2))   # 5.0
print(divide(10, 0))   # エラー: ゼロで割ることはできません
print(divide(10, "2"))  # エラー: 数値を入力してください

def process_data(data_list, operation):
    if operation == "sum":
        return sum(data_list)
    elif operation == "average":
        return sum(data_list) / len(data_list)
    elif operation == "max":
        return max(data_list)
    elif operation == "min":
        return min(data_list)
    else:
        return "無効な操作です"

data = [10, 20, 30, 40, 50]
print(process_data(data, "sum"))     # 150
print(process_data(data, "average")) # 30.0
print(process_data(data, "max"))     # 50
print(process_data(data, "min"))     # 10

def update_dict(data_dict, key, value):
    if key in data_dict:
        data_dict[key] = value
        return f"{key}の値を{value}に更新しました"
    else:
        data_dict[key] = value
        return f"新しいキー{key}を値{value}で追加しました"

my_dict = {"apple": 5, "banana": 3}
print(update_dict(my_dict, "apple", 10))  # appleの値を10に更新しました
print(update_dict(my_dict, "orange", 7))  # 新しいキーorangeを値7で追加しました
print(my_dict)  # {'apple': 10, 'banana': 3, 'orange': 7}

def select(data, conditions):
    result = []
    for item in data:
        if all(item[key] == value for key, value in conditions.items()):
            result.append(item)
    return result

def update(data, conditions, new_values):
    for item in data:
        if all(item[key] == value for key, value in conditions.items()):
            item.update(new_values)
    return data

# サンプルデータ
employees = [
    {"id": 1, "name": "田中", "dept": "営業", "salary": 300000},
    {"id": 2, "name": "佐藤", "dept": "開発", "salary": 350000},
    {"id": 3, "name": "鈴木", "dept": "営業", "salary": 280000},
]

# SELECT操作
print(select(employees, {"dept": "営業"}))
# [{'id': 1, 'name': '田中', 'dept': '営業', 'salary': 300000}, 
#  {'id': 3, 'name': '鈴木', 'dept': '営業', 'salary': 280000}]

# UPDATE操作
updated_employees = update(employees, {"id": 2}, {"salary": 380000})
print(updated_employees)
# [{'id': 1, 'name': '田中', 'dept': '営業', 'salary': 300000}, 
#  {'id': 2, 'name': '佐藤', 'dept': '開発', 'salary': 380000}, 
#  {'id': 3, 'name': '鈴木', 'dept': '営業', 'salary': 280000}]

import csv

def read_csv(filename):
    data = []
    with open(filename, 'r', encoding='utf-8') as file:
        reader = csv.DictReader(file)
        for row in reader:
            data.append(row)
    return data

def write_csv(filename, data):
    if not data:
        return "データが空です"

    keys = data[0].keys()
    with open(filename, 'w', encoding='utf-8', newline='') as file:
        writer = csv.DictWriter(file, fieldnames=keys)
        writer.writeheader()
        writer.writerows(data)
    return f"{filename}にデータを書き込みました"

# CSVファイルを読み込む
employees = read_csv('employees.csv')
print(employees)

# データを更新
employees[0]['salary'] = '320000'

# 更新したデータをCSVファイルに書き込む
result = write_csv('updated_employees.csv', employees)
print(result)

import time

def find_max_simple(numbers):
    max_num = numbers[0]
    for num in numbers:
        if num > max_num:
            max_num = num
    return max_num

def find_max_builtin(numbers):
    return max(numbers)

# パフォーマンスを比較
numbers = list(range(1000000))  # 0から999999までの数字のリスト

start = time.time()
result1 = find_max_simple(numbers)
end = time.time()
print(f"自作関数の実行時間: {end - start:.6f}秒")

start = time.time()
result2 = find_max_builtin(numbers)
end = time.time()
print(f"組み込み関数の実行時間: {end - start:.6f}秒")

print(f"結果が一致するか: {result1 == result2}")

自作関数の実行時間: 0.064953秒
組み込み関数の実行時間: 0.013988秒
結果が一致するか: True

import time

def filter_even_loop(numbers):
    result = []
    for num in numbers:
        if num % 2 == 0:
            result.append(num)
    return result

def filter_even_list_comp(numbers):
    return [num for num in numbers if num % 2 == 0]

def filter_even_builtin(numbers):
    return list(filter(lambda x: x % 2 == 0, numbers))

# パフォーマンスを比較
numbers = list(range(1000000))  # 0から999999までの数字のリスト

start = time.time()
result1 = filter_even_loop(numbers)
end = time.time()
print(f"ループの実行時間: {end - start:.6f}秒")

start = time.time()
result2 = filter_even_list_comp(numbers)
end = time.time()
print(f"リスト内包表記の実行時間: {end - start:.6f}秒")

start = time.time()
result3 = filter_even_builtin(numbers)
end = time.time()
print(f"組み込み関数の実行時間: {end - start:.6f}秒")

print(f"結果が一致するか: {result1 == result2 == result3}")

ループの実行時間: 0.144314秒
リスト内包表記の実行時間: 0.063539秒
組み込み関数の実行時間: 0.082054秒
結果が一致するか: True

import unittest

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

class TestAddFunction(unittest.TestCase):
    def test_add_positive_numbers(self):
        self.assertEqual(add(2, 3), 5)

    def test_add_negative_numbers(self):
        self.assertEqual(add(-1, -1), -2)

    def test_add_mixed_numbers(self):
        self.assertEqual(add(-1, 1), 0)

if __name__ == '__main__':
    unittest.main()

...
----------------------------------------------------------------------
Ran 3 tests in 0.001s

OK

# test_functions.py
import pytest

def divide(a, b):
    if b == 0:
        raise ValueError("0で割ることはできません")
    return a / b

def test_divide_positive_numbers():
    assert divide(6, 3) == 2

def test_divide_negative_numbers():
    assert divide(-6, -3) == 2

def test_divide_by_zero():
    with pytest.raises(ValueError):
        divide(6, 0)

============================= test session starts ==============================
collected 3 items

test_functions.py ...                                                    [100%]

============================== 3 passed in 0.02s ===============================

def greet(name="Guest"):
    return f"Hello, {name}!"

print(greet())        # Hello, Guest!
print(greet("Alice")) # Hello, Alice!

function greet(name = "Guest") {
    return `Hello, ${name}!`;
}

console.log(greet());     // Hello, Guest!
console.log(greet("Bob")); // Hello, Bob!

Function Add(a As Integer, b As Integer) As Integer
    Add = a + b
End Function

Sub Main()
    Dim result As Integer
    result = Add(3, 4)
    Debug.Print result
End Sub

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

result = add(3, 4)
print(result)

def greet(name):
    return f"Hello, {name}!"

# 関数を変数に代入
say_hello = greet
print(say_hello("Alice"))  # Hello, Alice!

// 従来の関数定義
function greet(name) {
    return `Hello, ${name}!`;
}

// アロー関数
const greetArrow = name => `Hello, ${name}!`;

console.log(greet("Bob"));      // Hello, Bob!
console.log(greetArrow("Charlie"));  // Hello, Charlie!

public class Greeter {
    public static String greet(String name) {
        return "Hello, " + name + "!";
    }

    public static void main(String[] args) {
        System.out.println(greet("David"));  // Hello, David!
    }
}

#include <iostream>
#include <string>

std::string greet(const std::string& name) {
    return "Hello, " + name + "!";
}

int main() {
    std::cout << greet("Eve") << std::endl;  // Hello, Eve!
    return 0;
}

def greet(name)
  "Hello, #{name}!"
end

puts greet("Frank")  # Hello, Frank!

def calculate_area(length, width):
    """
    長方形の面積を計算します。

    Args:
        length (float): 長方形の長さ
        width (float): 長方形の幅

    Returns:
        float: 計算された面積

    Raises:
        ValueError: 長さまたは幅が負の値の場合

    Example:
        >>> calculate_area(5, 3)
        15.0
    """
    if length < 0 or width < 0:
        raise ValueError("長さと幅は正の値である必要があります")
    return length * width

# docstringの内容を表示
print(calculate_area.__doc__)

# 関数を使用
try:
    area = calculate_area(5, 3)
    print(f"面積: {area}")
except ValueError as e:
    print(f"エラー: {e}")

    長方形の面積を計算します。

    Args:
        length (float): 長方形の長さ
        width (float): 長方形の幅

    Returns:
        float: 計算された面積

    Raises:
        ValueError: 長さまたは幅が負の値の場合

    Example:
        >>> calculate_area(5, 3)
        15.0

面積: 15.0

from typing import List, Dict, Union

def process_data(numbers: List[int], operations: Dict[str, bool]) -> Union[int, float]:
    """
    数値リストに対して指定された操作を実行します。

    Args:
        numbers (List[int]): 処理する整数のリスト
        operations (Dict[str, bool]): 実行する操作を指定する辞書
                                      'sum': 合計を計算
                                      'average': 平均を計算

    Returns:
        Union[int, float]: 操作結果。合計の場合は整数、平均の場合は浮動小数点数

    Raises:
        ValueError: 無効な操作が指定された場合
    """
    if not numbers:
        raise ValueError("数値リストが空です")

    if operations.get('sum'):
        return sum(numbers)
    elif operations.get('average'):
        return sum(numbers) / len(numbers)
    else:
        raise ValueError("有効な操作が指定されていません")

# 関数を使用
try:
    result1 = process_data([1, 2, 3, 4, 5], {'sum': True})
    print(f"合計: {result1}")

    result2 = process_data([1, 2, 3, 4, 5], {'average': True})
    print(f"平均: {result2}")

    # エラーを発生させる例
    process_data([], {'sum': True})
except ValueError as e:
    print(f"エラー: {e}")

合計: 15
平均: 3.0
エラー: 数値リストが空です

def greet(name: str, age: int):
    print(f"{name}さん、{age}歳の誕生日おめでとうございます！")

# 正しい使用法
greet("太郎", 30)

# エラーが発生する例
try:
    greet("花子")  # 引数が足りない
except TypeError as e:
    print(f"エラー1: {e}")

try:
    greet("次郎", "25")  # 型が不正
except TypeError as e:
    print(f"エラー2: {e}")

太郎さん、30歳の誕生日おめでとうございます！
エラー1: greet() missing 1 required positional argument: 'age'
エラー2: greet() argument 2 must be int, not str

x = 10

def modify_variable():
    x = 20  # ローカル変数を作成
    print(f"関数内のx: {x}")

modify_variable()
print(f"グローバルなx: {x}")

def modify_global_variable():
    global x
    x = 30
    print(f"グローバル変数を変更したx: {x}")

modify_global_variable()
print(f"変更後のグローバルなx: {x}")

関数内のx: 20
グローバルなx: 10
グローバル変数を変更したx: 30
変更後のグローバルなx: 30

def countdown_incorrect(n):
    print(n)
    countdown_incorrect(n - 1)  # 終了条件がない

# 修正版
def countdown_correct(n):
    if n < 0:  # 終了条件
        return
    print(n)
    countdown_correct(n - 1)

# 使用例
print("正しい実装:")
countdown_correct(5)

print("\n誤った実装:")
try:
    countdown_incorrect(5)
except RecursionError as e:
    print(f"エラー: {e}")

正しい実装:
5
4
3
2
1
0

誤った実装:
5
4
3
2
1
0
-1
-2
...
エラー: maximum recursion depth exceeded while calling a Python object

def fibonacci_memo(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fibonacci_memo(n-1, memo) + fibonacci_memo(n-2, memo)
    return memo[n]

# 使用例
for i in range(10):
    print(f"F({i}) = {fibonacci_memo(i)}")

F(0) = 0
F(1) = 1
F(2) = 1
F(3) = 2
F(4) = 3
F(5) = 5
F(6) = 8
F(7) = 13
F(8) = 21
F(9) = 34

import pandas as pd
import matplotlib.pyplot as plt

def analyze_sales_by_category(df, category, min_sales=0):
    """
    指定されたカテゴリーの売上データを分析し、棒グラフで表示します。

    Args:
        df (pandas.DataFrame): 売上データを含むDataFrame
        category (str): 分析対象のカテゴリー
        min_sales (int): 表示する最小売上額（デフォルト: 0）

    Returns:
        None
    """
    # カテゴリーでフィルタリングし、最小売上額以上のデータを抽出
    filtered_data = df[(df['Category'] == category) & (df['Sales'] >= min_sales)]

    # 製品ごとの売上を集計
    sales_by_product = filtered_data.groupby('Product')['Sales'].sum().sort_values(ascending=False)

    # 棒グラフの作成
    plt.figure(figsize=(12, 6))
    sales_by_product.plot(kind='bar')
    plt.title(f'{category}カテゴリーの製品別売上')
    plt.xlabel('製品名')
    plt.ylabel('売上額')
    plt.xticks(rotation=45, ha='right')
    plt.tight_layout()
    plt.show()

# サンプルデータの作成
data = {
    'Product': ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'],
    'Category': ['Electronics', 'Clothing', 'Electronics', 'Clothing', 'Electronics', 'Food', 'Food', 'Electronics'],
    'Sales': [1000, 500, 1500, 800, 2000, 300, 400, 1200]
}
df = pd.DataFrame(data)

# 関数の使用
analyze_sales_by_category(df, 'Electronics', min_sales=500)

import pygame
import sys

# Pygameの初期化
pygame.init()

# 画面設定
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("2Dゲームの例")

# キャラクターの設定
character_size = 50
character_x = WIDTH // 2
character_y = HEIGHT // 2
character_speed = 5

def move_character(x, y, dx, dy):
    """
    キャラクターを移動し、画面内に収まるように位置を調整します。

    Args:
        x (int): 現在のX座標
        y (int): 現在のY座標
        dx (int): X方向の移動量
        dy (int): Y方向の移動量

    Returns:
        tuple: 調整後の(x, y)座標
    """
    new_x = x + dx
    new_y = y + dy

    # 画面の境界をチェック
    new_x = max(0, min(new_x, WIDTH - character_size))
    new_y = max(0, min(new_y, HEIGHT - character_size))

    return new_x, new_y

# ゲームループ
running = True
clock = pygame.time.Clock()

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # キー入力の処理
    keys = pygame.key.get_pressed()
    dx = (keys[pygame.K_RIGHT] - keys[pygame.K_LEFT]) * character_speed
    dy = (keys[pygame.K_DOWN] - keys[pygame.K_UP]) * character_speed

    # キャラクターの移動
    character_x, character_y = move_character(character_x, character_y, dx, dy)

    # 画面の描画
    screen.fill((255, 255, 255))  # 白色の背景
    pygame.draw.rect(screen, (255, 0, 0), (character_x, character_y, character_size, character_size))
    pygame.display.flip()

    clock.tick(60)  # 60FPSに制限

pygame.quit()
sys.exit()

from flask import Flask, request, jsonify
import re

app = Flask(__name__)

def validate_email(email):
    """
    メールアドレスの形式を検証します。

    Args:
        email (str): 検証するメールアドレス

    Returns:
        bool: メールアドレスが有効な形式の場合はTrue、そうでない場合はFalse
    """
    pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
    return re.match(pattern, email) is not None

def format_name(name):
    """
    名前を整形します（先頭文字を大文字に、残りを小文字に）。

    Args:
        name (str): 整形する名前

    Returns:
        str: 整形された名前
    """
    return name.capitalize()

@app.route('/register', methods=['POST'])
def register_user():
    data = request.json
    email = data.get('email')
    name = data.get('name')

    if not email or not name:
        return jsonify({'error': '名前とメールアドレスは必須です'}), 400

    if not validate_email(email):
        return jsonify({'error': '無効なメールアドレスです'}), 400

    formatted_name = format_name(name)

    # ここでユーザー登録処理を行うと仮定します（実際の実装は省略）

    return jsonify({
        'message': '登録成功',
        'user': {
            'name': formatted_name,
            'email': email
        }
    }), 201

if __name__ == '__main__':
    app.run(debug=True)

{
  "message": "登録成功",
  "user": {
    "name": "John doe",
    "email": "john.doe@example.com"
  }
}

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

def preprocess_data(df, target_column):
    """
    データの前処理を行います。

    Args:
        df (pandas.DataFrame): 前処理するデータフレーム
        target_column (str): ターゲット変数の列名

    Returns:
        tuple: (X, y, X_train, X_test, y_train, y_test)
    """
    X = df.drop(target_column, axis=1)
    y = df[target_column]

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

    scaler = StandardScaler()
    X_train_scaled = scaler.fit_transform(X_train)
    X_test_scaled = scaler.transform(X_test)

    return X, y, X_train_scaled, X_test_scaled, y_train, y_test

def train_and_evaluate_model(X_train, X_test, y_train, y_test):
    """
    モデルのトレーニングと評価を行います。

    Args:
        X_train, X_test, y_train, y_test: トレーニングデータとテストデータ

    Returns:
        tuple: (trained_model, accuracy, classification_report)
    """
    model = RandomForestClassifier(n_estimators=100, random_state=42)
    model.fit(X_train, y_train)

    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    report = classification_report(y_test, y_pred)

    return model, accuracy, report

# サンプルデータの生成（実際のプロジェクトではこの部分は実データに置き換えます）
np.random.seed(42)
data = {
    'feature1': np.random.rand(1000),
    'feature2': np.random.rand(1000),
    'feature3': np.random.rand(1000),
    'target': np.random.choice([0, 1], size=1000)
}
df = pd.DataFrame(data)

# データの前処理
X, y, X_train, X_test, y_train, y_test = preprocess_data(df, 'target')

# モデルのトレーニングと評価
model, accuracy, report = train_and_evaluate_model(X_train, X_test, y_train, y_test)

print(f"モデルの精度: {accuracy:.2f}")
print("分類レポート:")
print(report)

モデルの精度: 0.95
分類レポート:
              precision    recall  f1-score   support

           0       0.94      0.96      0.95       102
           1       0.96      0.94      0.95        98

    accuracy                           0.95       200
   macro avg       0.95      0.95      0.95       200
weighted avg       0.95      0.95      0.95       200

# 異なる特徴量の組み合わせを試す
feature_sets = [
    ['feature1', 'feature2'],
    ['feature1', 'feature3'],
    ['feature2', 'feature3'],
    ['feature1', 'feature2', 'feature3']
]

for features in feature_sets:
    print(f"\n特徴量: {features}")
    df_subset = df[features + ['target']]
    X, y, X_train, X_test, y_train, y_test = preprocess_data(df_subset, 'target')
    model, accuracy, report = train_and_evaluate_model(X_train, X_test, y_train, y_test)
    print(f"モデルの精度: {accuracy:.2f}")