関数をモジュールに分離して管理する方法と活用例9選

# math_operations.py

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

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b != 0:
        return a / b
    else:
        return "エラー：ゼロで割ることはできません"

# main.py

import math_operations

result = math_operations.add(5, 3)
print(result)  # 出力: 8

result = math_operations.multiply(4, 7)
print(result)  # 出力: 28

# string_utils.py

def reverse_string(s):
    return s[::-1]

def count_vowels(s):
    vowels = 'aeiouAEIOU'
    return sum(1 for char in s if char in vowels)

def is_palindrome(s):
    s = ''.join(char.lower() for char in s if char.isalnum())
    return s == s[::-1]

# main.py

import string_utils

text = "Hello, World!"
print(string_utils.reverse_string(text))  # 出力: !dlroW ,olleH
print(string_utils.count_vowels(text))    # 出力: 3
print(string_utils.is_palindrome("A man a plan a canal Panama"))  # 出力: True

# math_advanced.py

import math

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

def fibonacci(n):
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    else:
        fib = [0, 1]
        for i in range(2, n):
            fib.append(fib[i-1] + fib[i-2])
        return fib

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

# main.py

import math_advanced

print(math_advanced.factorial(5))        # 出力: 120
print(math_advanced.fibonacci(8))        # 出力: [0, 1, 1, 2, 3, 5, 8, 13]
print(math_advanced.is_prime(17))        # 出力: True
print(math_advanced.gcd(48, 18))         # 出力: 6

my_package/
    __init__.py
    module1.py
    module2.py

# module1.py
def greet():
    return "Hello from module1!"

# module2.py
def farewell():
    return "Goodbye from module2!"

# __init__.py
from .module1 import greet
from .module2 import farewell

def package_function():
    return "This is a function defined in the package"

# main.py
import my_package

print(my_package.greet())           # 出力: Hello from module1!
print(my_package.farewell())        # 出力: Goodbye from module2!
print(my_package.package_function()) # 出力: This is a function defined in the package

# __init__.py
from .module1 import greet
from .module2 import farewell

__all__ = ['greet', 'farewell']

def package_function():
    return "This is a function defined in the package"

my_project/
│
├── main.py
├── config/
│   └── settings.py
├── modules/
│   ├── module1.py
│   ├── module2.py
│   └── __init__.py
├── utils/
│   ├── helper_functions.py
│   └── __init__.py
├── tests/
│   ├── test_module1.py
│   └── test_module2.py
└── docs/
    └── README.md

def calculate_average(numbers):
    """
    与えられた数値リストの平均値を計算します。

    Args:
        numbers (list): 平均を計算する数値のリスト

    Returns:
        float: 計算された平均値

    Raises:
        ValueError: リストが空の場合
    """
    if not numbers:
        raise ValueError("リストが空です")
    return sum(numbers) / len(numbers)

# プロジェクト名

## 概要
簡潔なプロジェクトの説明を書きます。

## セットアップ
1. リポジトリをクローンします。
2. 必要な依存関係をインストールします。
3. 設定ファイルを編集します。

## 使用例
基本的な使用方法を示すコード例を記述します。

## ライセンス
このプロジェクトのライセンス情報を記述します。

# data_processor.py

import csv
import sqlite3

def read_csv(file_path):
    """CSVファイルを読み込み、リストとして返す"""
    with open(file_path, 'r') as file:
        reader = csv.reader(file)
        return list(reader)

def write_to_database(data, db_path):
    """データをSQLiteデータベースに書き込む"""
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    cursor.execute('''CREATE TABLE IF NOT EXISTS data
                      (id INTEGER PRIMARY KEY, name TEXT, value INTEGER)''')
    cursor.executemany('INSERT INTO data (name, value) VALUES (?, ?)', data)
    conn.commit()
    conn.close()

def process_data(input_file, output_db):
    """CSVファイルを読み込み、データベースに書き込む"""
    data = read_csv(input_file)
    write_to_database(data[1:], output_db)  # ヘッダーを除外

# main.py

from data_processor import process_data

process_data('input.csv', 'output.db')
print("データ処理が完了しました。")

# utils.py

import re
from datetime import datetime

def camel_to_snake(string):
    """キャメルケースをスネークケースに変換"""
    pattern = re.compile(r'(?<!^)(?=[A-Z])')
    return pattern.sub('_', string).lower()

def get_current_timestamp():
    """現在のタイムスタンプを取得"""
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

def truncate_string(string, length, suffix='...'):
    """文字列を指定の長さに切り詰める"""
    if len(string) <= length:
        return string
    return string[:length - len(suffix)] + suffix

# main.py

from utils import camel_to_snake, get_current_timestamp, truncate_string

print(camel_to_snake("helloWorld"))
print(get_current_timestamp())
print(truncate_string("This is a very long string", 10))

hello_world
2023-04-15 14:30:22
This is a..

# weather_api.py

import requests

API_KEY = "your_api_key_here"
BASE_URL = "http://api.openweathermap.org/data/2.5/weather"

def get_weather(city):
    """指定された都市の天気情報を取得"""
    params = {
        "q": city,
        "appid": API_KEY,
        "units": "metric"
    }
    response = requests.get(BASE_URL, params=params)
    data = response.json()

    if response.status_code == 200:
        return {
            "city": data["name"],
            "temperature": data["main"]["temp"],
            "description": data["weather"][0]["description"]
        }
    else:
        return {"error": "天気情報の取得に失敗しました"}

# main.py

from weather_api import get_weather

tokyo_weather = get_weather("Tokyo")
print(f"東京の天気: {tokyo_weather['temperature']}°C, {tokyo_weather['description']}")

# config_manager.py

import json
import os

class ConfigManager:
    def __init__(self, config_file):
        self.config_file = config_file
        self.config = self.load_config()

    def load_config(self):
        """設定ファイルを読み込む"""
        with open(self.config_file, 'r') as file:
            return json.load(file)

    def get(self, key, default=None):
        """設定値を取得する"""
        return self.config.get(key, default)

    def set(self, key, value):
        """設定値を設定する"""
        self.config[key] = value
        self.save_config()

    def save_config(self):
        """設定をファイルに保存する"""
        with open(self.config_file, 'w') as file:
            json.dump(self.config, file, indent=4)

    @staticmethod
    def get_env(key, default=None):
        """環境変数を取得する"""
        return os.environ.get(key, default)

{
    "database_url": "sqlite:///app.db",
    "debug_mode": true
}

# main.py

from config_manager import ConfigManager

config = ConfigManager('config.json')

print(f"データベースURL: {config.get('database_url')}")
print(f"デバッグモード: {config.get('debug_mode')}")

# 設定を変更
config.set('debug_mode', False)

# 環境変数を取得
api_key = ConfigManager.get_env('API_KEY', 'default_key')
print(f"API Key: {api_key}")

データベースURL: sqlite:///app.db
デバッグモード: True
API Key: default_key

# custom_logger.py

import logging
import os
from logging.handlers import RotatingFileHandler

def setup_logger(name, log_file, level=logging.INFO):
    """ロガーをセットアップする"""
    formatter = logging.Formatter('%(asctime)s %(levelname)s: %(message)s')

    handler = RotatingFileHandler(log_file, maxBytes=1024*1024, backupCount=5)
    handler.setFormatter(formatter)

    logger = logging.getLogger(name)
    logger.setLevel(level)
    logger.addHandler(handler)

    return logger

# アプリケーション全体で使用するロガーを作成
app_logger = setup_logger('app_logger', 'app.log')
error_logger = setup_logger('error_logger', 'error.log', level=logging.ERROR)

# main.py

from custom_logger import app_logger, error_logger

def divide(a, b):
    try:
        result = a / b
        app_logger.info(f"{a} / {b} = {result}")
        return result
    except ZeroDivisionError:
        error_logger.error("ゼロ除算エラーが発生しました")
        return None

divide(10, 2)
divide(5, 0)

# test_utils.py

import unittest
from utils import camel_to_snake, truncate_string

class TestUtils(unittest.TestCase):
    def test_camel_to_snake(self):
        self.assertEqual(camel_to_snake("helloWorld"), "hello_world")
        self.assertEqual(camel_to_snake("HTTPResponse"), "http_response")
        self.assertEqual(camel_to_snake("ABC"), "abc")

    def test_truncate_string(self):
        self.assertEqual(truncate_string("Hello, World!", 5), "He...")
        self.assertEqual(truncate_string("Short", 10), "Short")
        self.assertEqual(truncate_string("Very long string", 10, "..."), "Very lo...")

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

..
----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK

# current_module.py
from .other_module import some_function

# some_module.py
from project.sub_package.other_module import some_function

# module_a.py
from module_b import function_b

def function_a():
    return "Function A"

# module_b.py
from module_a import function_a

def function_b():
    return "Function B"

# module_a.py
def function_a():
    from module_b import function_b
    return "Function A calling " + function_b()

# module_b.py
def function_b():
    from module_a import function_a
    return "Function B calling " + function_a()

import sys
print(sys.path)

def process_data(data):
    # データの検証
    if not isinstance(data, list):
        raise ValueError("データはリスト形式である必要があります")

    # データの変換
    converted_data = [item.upper() for item in data if isinstance(item, str)]

    # データの集計
    total = sum(len(item) for item in converted_data)

    # 結果の出力
    print(f"変換されたデータ: {converted_data}")
    print(f"合計文字数: {total}")

    return converted_data, total

# 使用例
result = process_data(['hello', 'world', 123, 'python'])

# data_validator.py
def validate_data(data):
    if not isinstance(data, list):
        raise ValueError("データはリスト形式である必要があります")

# data_converter.py
def convert_data(data):
    return [item.upper() for item in data if isinstance(item, str)]

# data_analyzer.py
def calculate_total(data):
    return sum(len(item) for item in data)

# main.py
from data_validator import validate_data
from data_converter import convert_data
from data_analyzer import calculate_total

def process_data(data):
    validate_data(data)
    converted_data = convert_data(data)
    total = calculate_total(converted_data)

    print(f"変換されたデータ: {converted_data}")
    print(f"合計文字数: {total}")

    return converted_data, total

# 使用例
result = process_data(['hello', 'world', 123, 'python'])

# config.py
import os

DATABASE_URL = os.getenv('DATABASE_URL', 'sqlite:///default.db')
DEBUG_MODE = os.getenv('DEBUG_MODE', 'False').lower() == 'true'

# database.py
from config import DATABASE_URL

def connect_to_database():
    # DATABASE_URLを使用してデータベースに接続する処理
    pass

# data_processor.py
class DataProcessor:
    def process(self, data):
        raise NotImplementedError("Subclasses must implement this method")

# text_processor.py
from data_processor import DataProcessor

class TextProcessor(DataProcessor):
    def process(self, data):
        return data.upper()

# number_processor.py
from data_processor import DataProcessor

class NumberProcessor(DataProcessor):
    def process(self, data):
        return data * 2

def calculate_average(numbers):
    """
    数値のリストの平均値を計算します。

    Args:
        numbers (list of int or float): 平均を計算する数値のリスト

    Returns:
        float: 計算された平均値

    Raises:
        ValueError: リストが空の場合、または数値以外の要素が含まれる場合

    Example:
        >>> calculate_average([1, 2, 3, 4, 5])
        3.0
    """
    if not numbers:
        raise ValueError("リストが空です")
    if not all(isinstance(n, (int, float)) for n in numbers):
        raise ValueError("リストには数値以外の要素が含まれています")
    return sum(numbers) / len(numbers)

my_project/
    ├── main.py
    ├── config/
    │   ├── __init__.py
    │   ├── development.py
    │   └── production.py
    ├── data_processing/
    │   ├── __init__.py
    │   ├── loader.py
    │   └── transformer.py
    ├── analysis/
    │   ├── __init__.py
    │   ├── statistical.py
    │   └── machine_learning.py
    └── utils/
        ├── __init__.py
        ├── logging.py
        └── helpers.py

# requirements.txt
numpy==1.21.0
pandas==1.3.0
scikit-learn==0.24.2

# __init__.py
__version__ = "1.2.3"

# test_data_processing.py
import unittest
from data_processing import loader, transformer

class TestDataProcessing(unittest.TestCase):
    def test_loader(self):
        # loaderモジュールのテスト
        pass

    def test_transformer(self):
        # transformerモジュールのテスト
        pass

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

# data_processing/loader.py

def load_data(file_path):
    """
    指定されたファイルからデータを読み込みます。

    Args:
        file_path (str): 読み込むファイルのパス

    Returns:
        pandas.DataFrame: 読み込まれたデータ

    Raises:
        FileNotFoundError: ファイルが見つからない場合
    """
    # データ読み込みの実装
    pass

# .pylintrc
[MASTER]
ignore=CVS
ignore-patterns=
persistent=yes
load-plugins=
jobs=1
unsafe-load-any-extension=no
extension-pkg-whitelist=

[MESSAGES CONTROL]
confidence=
disable=C0111

# .github/workflows/ci.yml
name: CI

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.9'
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Run tests
      run: python -m unittest discover tests
    - name: Run linter
      run: pylint **/*.py