Pythonにおける定数管理の基本と実践20選

# 定数の定義
PI = 3.14159
GRAVITY = 9.8

# 円の面積を計算する関数
def calculate_circle_area(radius):
    return PI * radius ** 2

# 自由落下の距離を計算する関数
def calculate_free_fall_distance(time):
    return 0.5 * GRAVITY * time ** 2

# 定数を使用した計算
radius = 5
time = 3

circle_area = calculate_circle_area(radius)
fall_distance = calculate_free_fall_distance(time)

print(f"半径{radius}の円の面積: {circle_area:.2f}")
print(f"{time}秒間の自由落下距離: {fall_distance:.2f}m")

半径5の円の面積: 78.54
3秒間の自由落下距離: 44.10m

# グローバル定数
GRAVITY = 9.8
PI = 3.14159

class PhysicsCalculator:
    # クラス定数
    PLANCK_CONSTANT = 6.62607015e-34

    def __init__(self):
        # インスタンス定数（通常はコンストラクタで初期化）
        self.MASS = 1.0

    def calculate_potential_energy(self, height):
        return self.MASS * GRAVITY * height

    def calculate_circular_velocity(self, radius):
        return (GRAVITY * radius) ** 0.5

    def calculate_photon_energy(self, frequency):
        return self.PLANCK_CONSTANT * frequency

# 使用例
calculator = PhysicsCalculator()

height = 10
radius = 6371000  # 地球の半径（メートル）
frequency = 5e14  # 可視光の周波数

potential_energy = calculator.calculate_potential_energy(height)
circular_velocity = calculator.calculate_circular_velocity(radius)
photon_energy = calculator.calculate_photon_energy(frequency)

print(f"位置エネルギー: {potential_energy:.2f} J")
print(f"円運動の速度: {circular_velocity:.2f} m/s")
print(f"光子のエネルギー: {photon_energy:.2e} J")

位置エネルギー: 98.00 J
円運動の速度: 7905.37 m/s
光子のエネルギー: 3.31e-19 J

# constants.py

# 物理定数
GRAVITY = 9.8
SPEED_OF_LIGHT = 299792458

# 数学定数
PI = 3.14159
E = 2.71828

# アプリケーション固有の定数
MAX_USERS = 1000
DEFAULT_TIMEOUT = 30

# 設定
DEBUG_MODE = True
API_VERSION = "v1.0"

# main.py

from constants import GRAVITY, SPEED_OF_LIGHT, PI, MAX_USERS, API_VERSION

def calculate_escape_velocity(planet_mass, planet_radius):
    return (2 * GRAVITY * planet_mass / planet_radius) ** 0.5

def calculate_relativistic_mass(rest_mass, velocity):
    return rest_mass / (1 - (velocity / SPEED_OF_LIGHT) ** 2) ** 0.5

def calculate_circle_circumference(radius):
    return 2 * PI * radius

# 使用例
earth_mass = 5.97e24  # kg
earth_radius = 6.37e6  # m
escape_velocity = calculate_escape_velocity(earth_mass, earth_radius)

spacecraft_speed = 1000  # m/s
spacecraft_mass = 1000  # kg
relativistic_mass = calculate_relativistic_mass(spacecraft_mass, spacecraft_speed)

circle_radius = 10
circumference = calculate_circle_circumference(circle_radius)

print(f"地球の脱出速度: {escape_velocity:.2f} m/s")
print(f"宇宙船の相対論的質量: {relativistic_mass:.2f} kg")
print(f"円周: {circumference:.2f} m")
print(f"最大ユーザー数: {MAX_USERS}")
print(f"API バージョン: {API_VERSION}")

地球の脱出速度: 11184.94 m/s
宇宙船の相対論的質量: 1000.00 kg
円周: 62.83 m
最大ユーザー数: 1000
API バージョン: v1.0

class MathConstants:
    PI = 3.14159
    E = 2.71828
    GOLDEN_RATIO = 1.61803

    @classmethod
    def is_close_to_pi(cls, value, tolerance=1e-5):
        return abs(cls.PI - value) < tolerance

class PhysicsConstants:
    GRAVITY = 9.8
    SPEED_OF_LIGHT = 299792458
    PLANCK_CONSTANT = 6.62607015e-34

    @classmethod
    def calculate_energy(cls, mass):
        return mass * cls.SPEED_OF_LIGHT ** 2

class ApplicationSettings:
    MAX_USERS = 1000
    DEFAULT_TIMEOUT = 30
    DEBUG_MODE = True

    @classmethod
    def is_debug_mode(cls):
        return cls.DEBUG_MODE

# 使用例
def calculate_circle_area(radius):
    return MathConstants.PI * radius ** 2

def calculate_free_fall_time(height):
    return (2 * height / PhysicsConstants.GRAVITY) ** 0.5

# テスト
print(f"円周率: {MathConstants.PI}")
print(f"3.14は円周率に近いか: {MathConstants.is_close_to_pi(3.14)}")

mass = 1  # kg
energy = PhysicsConstants.calculate_energy(mass)
print(f"質量1kgの物体のエネルギー: {energy:.2e} J")

fall_height = 100  # m
fall_time = calculate_free_fall_time(fall_height)
print(f"100mの自由落下時間: {fall_time:.2f} 秒")

print(f"アプリケーションはデバッグモードか: {ApplicationSettings.is_debug_mode()}")
print(f"最大ユーザー数: {ApplicationSettings.MAX_USERS}")

円周率: 3.14159
3.14は円周率に近いか: True
質量1kgの物体のエネルギー: 8.99e+16 J
100mの自由落下時間: 4.52 秒
アプリケーションはデバッグモードか: True
最大ユーザー数: 1000

from enum import Enum, auto

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

class Direction(Enum):
    NORTH = auto()
    SOUTH = auto()
    EAST = auto()
    WEST = auto()

# Enumの使用例
print(Color.RED)  # Color.RED
print(Color.RED.name)  # RED
print(Color.RED.value)  # 1

print(Direction.NORTH)  # Direction.NORTH
print(Direction.NORTH.name)  # NORTH
print(Direction.NORTH.value)  # 1

# Enumのイテレーション
for color in Color:
    print(f"{color.name}: {color.value}")

# Enumの比較
print(Color.RED == Color.RED)  # True
print(Color.RED == Color.BLUE)  # False
print(Color.RED == 1)  # False

# Enumの使用例：関数内での活用
def process_color(color: Color):
    if color == Color.RED:
        return "Stop"
    elif color == Color.GREEN:
        return "Go"
    elif color == Color.BLUE:
        return "Proceed with caution"
    else:
        return "Unknown color"

print(process_color(Color.GREEN))  # Go

Color.RED
RED
1
Direction.NORTH
NORTH
1
RED: 1
GREEN: 2
BLUE: 3
True
False
False
Go

from enum import Enum, auto, unique
from typing import List, Dict

@unique
class Fruit(Enum):
    APPLE = "りんご"
    BANANA = "バナナ"
    ORANGE = "オレンジ"

    def __str__(self):
        return f"{self.name}（{self.value}）"

class Size(Enum):
    SMALL = auto()
    MEDIUM = auto()
    LARGE = auto()

    def get_multiplier(self) -> float:
        multipliers = {Size.SMALL: 0.8, Size.MEDIUM: 1.0, Size.LARGE: 1.2}
        return multipliers[self]

class Pizza(Enum):
    MARGHERITA = {"ingredients": ["トマト", "モッツァレラ", "バジル"], "price": 1000}
    MARINARA = {"ingredients": ["トマト", "ニンニク", "オレガノ"], "price": 900}
    QUATTRO_FORMAGGI = {"ingredients": ["モッツァレラ", "ゴルゴンゾーラ", "パルメザン", "ペコリーノ"], "price": 1200}

    def get_ingredients(self) -> List[str]:
        return self.value["ingredients"]

    def get_price(self) -> int:
        return self.value["price"]

# Enumの使用例
print(Fruit.APPLE)  # APPLE（りんご）

size = Size.MEDIUM
price = 1000
adjusted_price = price * size.get_multiplier()
print(f"{size.name}サイズの価格: {adjusted_price}円")  # MEDIUMサイズの価格: 1000.0円

pizza = Pizza.MARGHERITA
print(f"{pizza.name}の材料: {', '.join(pizza.get_ingredients())}")
print(f"{pizza.name}の価格: {pizza.get_price()}円")

# Enumを辞書のキーとして使用
pizza_stock: Dict[Pizza, int] = {
    Pizza.MARGHERITA: 5,
    Pizza.MARINARA: 3,
    Pizza.QUATTRO_FORMAGGI: 2
}

for pizza, stock in pizza_stock.items():
    print(f"{pizza.name}の在庫: {stock}枚")

APPLE（りんご）
MEDIUMサイズの価格: 1000.0円
MARGHERITAの材料: トマト, モッツァレラ, バジル
MARGHERITAの価格: 1000円
MARGHERITAの在庫: 5枚
MARINARAの在庫: 3枚
QUATTRO_FORMAGGIの在庫: 2枚

class MathConstants:
    PI = 3.14159
    E = 2.71828
    GOLDEN_RATIO = 1.61803

    @classmethod
    def get_circle_area(cls, radius):
        return cls.PI * radius ** 2

    @classmethod
    def get_circle_circumference(cls, radius):
        return 2 * cls.PI * radius

class ColorConstants:
    RED = (255, 0, 0)
    GREEN = (0, 255, 0)
    BLUE = (0, 0, 255)

    @classmethod
    def rgb_to_hex(cls, rgb):
        return '#{:02x}{:02x}{:02x}'.format(*rgb)

# 定数クラスの使用例
radius = 5
print(f"円周率: {MathConstants.PI}")
print(f"半径{radius}の円の面積: {MathConstants.get_circle_area(radius):.2f}")
print(f"半径{radius}の円の周囲長: {MathConstants.get_circle_circumference(radius):.2f}")

print(f"赤色のRGB値: {ColorConstants.RED}")
print(f"赤色の16進数表現: {ColorConstants.rgb_to_hex(ColorConstants.RED)}")

円周率: 3.14159
半径5の円の面積: 78.54
半径5の円の周囲長: 31.42
赤色のRGB値: (255, 0, 0)
赤色の16進数表現: #ff0000

class Circle:
    PI = 3.14159  # クラス変数（定数として使用）

    def __init__(self, radius):
        self.radius = radius  # インスタンス変数

    @classmethod
    def from_diameter(cls, diameter):
        return cls(diameter / 2)

    def get_area(self):
        return self.PI * self.radius ** 2

    def get_circumference(self):
        return 2 * self.PI * self.radius

class Counter:
    count = 0  # クラス変数（変更可能）

    def __init__(self):
        self.id = Counter.count
        Counter.count += 1

    @classmethod
    def get_total_count(cls):
        return cls.count

# 使用例
circle1 = Circle(5)
circle2 = Circle.from_diameter(10)

print(f"円1の面積: {circle1.get_area():.2f}")
print(f"円2の周囲長: {circle2.get_circumference():.2f}")

counter1 = Counter()
counter2 = Counter()
counter3 = Counter()

print(f"作成されたカウンターの総数: {Counter.get_total_count()}")
print(f"カウンター1のID: {counter1.id}")
print(f"カウンター3のID: {counter3.id}")

円1の面積: 78.54
円2の周囲長: 31.42
作成されたカウンターの総数: 3
カウンター1のID: 0
カウンター3のID: 2

class BaseConfig:
    DEBUG = False
    DATABASE_URI = "sqlite:///default.db"
    SECRET_KEY = "default_secret_key"

    @classmethod
    def get_config_dict(cls):
        return {key: value for key, value in cls.__dict__.items() 
                if not key.startswith('__') and not callable(value)}

class DevelopmentConfig(BaseConfig):
    DEBUG = True
    DATABASE_URI = "sqlite:///development.db"

class ProductionConfig(BaseConfig):
    DATABASE_URI = "postgresql://user:password@localhost/production"
    SECRET_KEY = "production_secret_key"

class TestingConfig(BaseConfig):
    TESTING = True
    DATABASE_URI = "sqlite:///:memory:"

def get_config(env):
    configs = {
        "development": DevelopmentConfig,
        "production": ProductionConfig,
        "testing": TestingConfig
    }
    return configs.get(env, BaseConfig)

# 使用例
env = "development"
Config = get_config(env)

print(f"現在の環境: {env}")
print(f"設定内容:")
for key, value in Config.get_config_dict().items():
    print(f"  {key}: {value}")

# 別の環境での設定を確認
env = "production"
Config = get_config(env)

print(f"\n現在の環境: {env}")
print(f"設定内容:")
for key, value in Config.get_config_dict().items():
    print(f"  {key}: {value}")

現在の環境: development
設定内容:
  DEBUG: True
  DATABASE_URI: sqlite:///development.db
  SECRET_KEY: default_secret_key

現在の環境: production
設定内容:
  DEBUG: False
  DATABASE_URI: postgresql://user:password@localhost/production
  SECRET_KEY: production_secret_key

# .env
DEBUG=True
DATABASE_URL=sqlite:///db.sqlite3
SECRET_KEY=mysecretkey
MAX_CONNECTIONS=100

import os
from dotenv import load_dotenv

# .envファイルから環境変数を読み込む
load_dotenv()

# 環境変数を取得し、適切な型に変換する
DEBUG = os.getenv('DEBUG') == 'True'
DATABASE_URL = os.getenv('DATABASE_URL')
SECRET_KEY = os.getenv('SECRET_KEY')
MAX_CONNECTIONS = int(os.getenv('MAX_CONNECTIONS', 50))

# 定数の使用例
print(f"デバッグモード: {DEBUG}")
print(f"データベースURL: {DATABASE_URL}")
print(f"シークレットキー: {SECRET_KEY}")
print(f"最大接続数: {MAX_CONNECTIONS}")

# アプリケーションの設定例
if DEBUG:
    print("デバッグモードが有効です。本番環境では無効にしてください。")

# データベース接続の例
import sqlite3
conn = sqlite3.connect(DATABASE_URL.split(':///')[-1])
print("データベースに接続しました。")

# 接続数の制限例
if conn.total_changes > MAX_CONNECTIONS:
    print(f"警告：接続数が上限（{MAX_CONNECTIONS}）を超えています。")

デバッグモード: True
データベースURL: sqlite:///db.sqlite3
シークレットキー: mysecretkey
最大接続数: 100
デバッグモードが有効です。本番環境では無効にしてください。
データベースに接続しました。

import pandas as pd
import numpy as np

# NumPyの定数を使用した計算例
print(f"円周率（NumPy）: {np.pi}")
print(f"自然対数の底（NumPy）: {np.e}")

radius = 5
circle_area = np.pi * radius**2
print(f"半径{radius}の円の面積: {circle_area:.2f}")

# NumPyの特殊な定数
print(f"非常に小さな数（イプシロン）: {np.finfo(float).eps}")
print(f"浮動小数点数の最大値: {np.finfo(float).max}")

# pandasの日付関連定数を使用した例
print(f"1日の秒数: {pd.Timedelta.max.total_seconds()}")

# カスタム定数を定義して使用
GRAVITY = 9.8
PLANET_RADIUS = 6371  # km

def escape_velocity(planet_mass, planet_radius):
    return np.sqrt(2 * GRAVITY * planet_mass / (planet_radius * 1000))  # m/s

earth_mass = 5.97e24  # kg
v_escape = escape_velocity(earth_mass, PLANET_RADIUS)
print(f"地球の脱出速度: {v_escape:.2f} m/s")

# pandasを使用したデータ分析の例
data = pd.DataFrame({
    'A': np.random.randn(100) * 10,
    'B': np.random.randn(100) * 5,
    'C': np.random.randn(100) * 15
})

THRESHOLD = 10
above_threshold = data[data > THRESHOLD].count()
print(f"{THRESHOLD}を超える値の数:")
print(above_threshold)

円周率（NumPy）: 3.141592653589793
自然対数の底（NumPy）: 2.718281828459045
半径5の円の面積: 78.54
非常に小さな数（イプシロン）: 2.220446049250313e-16
浮動小数点数の最大値: 1.7976931348623157e+308
1日の秒数: 86400.0
地球の脱出速度: 11184.54 m/s
10を超える値の数:
A    49
B     5
C    66
dtype: int64

import requests
import os
from dotenv import load_dotenv

# .envファイルから環境変数を読み込む
load_dotenv()

# API関連の定数
API_BASE_URL = "https://api.example.com/v1"
API_KEY = os.getenv("API_KEY")
TIMEOUT = 30  # seconds

# エンドポイント定数
ENDPOINT_USERS = "/users"
ENDPOINT_POSTS = "/posts"

# HTTPメソッド定数
GET = "GET"
POST = "POST"
PUT = "PUT"
DELETE = "DELETE"

def api_request(method, endpoint, params=None, data=None):
    url = f"{API_BASE_URL}{endpoint}"
    headers = {"Authorization": f"Bearer {API_KEY}"}

    try:
        response = requests.request(
            method,
            url,
            headers=headers,
            params=params,
            json=data,
            timeout=TIMEOUT
        )
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"APIリクエストエラー: {e}")
        return None

# APIの使用例
def get_user(user_id):
    return api_request(GET, f"{ENDPOINT_USERS}/{user_id}")

def create_post(user_id, title, content):
    data = {
        "user_id": user_id,
        "title": title,
        "content": content
    }
    return api_request(POST, ENDPOINT_POSTS, data=data)

# 使用例
user_data = get_user(123)
if user_data:
    print(f"ユーザー情報: {user_data}")

new_post = create_post(123, "新しい投稿", "これは新しい投稿の内容です。")
if new_post:
    print(f"新しい投稿: {new_post}")

import os

# 環境変数の設定
os.environ['APP_ENV'] = 'development'
os.environ['DEBUG'] = 'True'
os.environ['MAX_CONNECTIONS'] = '100'

# 環境変数の取得
app_env = os.environ.get('APP_ENV')
debug = os.environ.get('DEBUG') == 'True'
max_connections = int(os.environ.get('MAX_CONNECTIONS', '50'))

print(f"アプリケーション環境: {app_env}")
print(f"デバッグモード: {debug}")
print(f"最大接続数: {max_connections}")

# 環境変数の存在確認
if 'SECRET_KEY' in os.environ:
    print(f"シークレットキー: {os.environ['SECRET_KEY']}")
else:
    print("警告: シークレットキーが設定されていません")

# 環境変数の削除
if 'TEMPORARY_VAR' in os.environ:
    del os.environ['TEMPORARY_VAR']

# 全ての環境変数の表示
print("\n全環境変数:")
for key, value in os.environ.items():
    print(f"{key}: {value}")

アプリケーション環境: development
デバッグモード: True
最大接続数: 100
警告: シークレットキーが設定されていません

全環境変数:
APP_ENV: development
DEBUG: True
MAX_CONNECTIONS: 100
... (その他の環境変数)

import os
from dataclasses import dataclass
from typing import Any

@dataclass
class AppConfig:
    DEBUG: bool
    DATABASE_URL: str
    SECRET_KEY: str
    MAX_CONNECTIONS: int
    FEATURE_FLAG_NEW_UI: bool

def load_config() -> AppConfig:
    return AppConfig(
        DEBUG=os.getenv('DEBUG', 'False').lower() == 'true',
        DATABASE_URL=os.getenv('DATABASE_URL', 'sqlite:///default.db'),
        SECRET_KEY=os.getenv('SECRET_KEY', 'default_secret_key'),
        MAX_CONNECTIONS=int(os.getenv('MAX_CONNECTIONS', '10')),
        FEATURE_FLAG_NEW_UI=os.getenv('FEATURE_FLAG_NEW_UI', 'False').lower() == 'true'
    )

# 設定のロード
config = load_config()

# アプリケーションでの使用例
def connect_to_database():
    print(f"データベースに接続: {config.DATABASE_URL}")
    # 実際のデータベース接続コードをここに記述

def process_request():
    if config.DEBUG:
        print("デバッグモードで実行中")

    if config.FEATURE_FLAG_NEW_UI:
        print("新UIを使用")
    else:
        print("従来のUIを使用")

# 設定の使用
print(f"アプリケーション設定:")
print(f"デバッグモード: {config.DEBUG}")
print(f"最大接続数: {config.MAX_CONNECTIONS}")

connect_to_database()
process_request()

# 設定の動的な変更（実際のアプリケーションでは注意が必要）
os.environ['DEBUG'] = 'True'
os.environ['FEATURE_FLAG_NEW_UI'] = 'True'

# 設定の再ロード
config = load_config()

print("\n設定変更後:")
process_request()

アプリケーション設定:
デバッグモード: False
最大接続数: 10
データベースに接続: sqlite:///default.db
従来のUIを使用

設定変更後:
デバッグモードで実行中
新UIを使用

# リストを使った定数の定義
ALLOWED_USERS = ['admin', 'moderator', 'editor']
PRIME_NUMBERS = [2, 3, 5, 7, 11, 13, 17, 19]

# 辞書を使った定数の定義
HTTP_STATUS_CODES = {
    200: 'OK',
    201: 'Created',
    400: 'Bad Request',
    404: 'Not Found',
    500: 'Internal Server Error'
}

COLOR_RGB = {
    'red': (255, 0, 0),
    'green': (0, 255, 0),
    'blue': (0, 0, 255)
}

# 定数の使用例
def check_user_permission(username):
    return username in ALLOWED_USERS

def is_prime(number):
    return number in PRIME_NUMBERS

def get_http_status_message(code):
    return HTTP_STATUS_CODES.get(code, 'Unknown Status Code')

def get_rgb_value(color_name):
    return COLOR_RGB.get(color_name, (0, 0, 0))

# テスト
print(check_user_permission('admin'))  # True
print(check_user_permission('user'))   # False
print(is_prime(7))   # True
print(is_prime(12))  # False
print(get_http_status_message(404))  # 'Not Found'
print(get_rgb_value('green'))  # (0, 255, 0)

True
False
True
False
Not Found
(0, 255, 0)

import numpy as np

# NumPy配列を使った定数の定義
FIBONACCI_SEQUENCE = np.array([0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144])
CONVERSION_FACTORS = np.array([1, 1000, 1000000, 1000000000])  # 単位変換用

# 定数の使用例
def is_fibonacci(number):
    return number in FIBONACCI_SEQUENCE

def convert_units(value, from_unit, to_unit):
    units = ['B', 'KB', 'MB', 'GB']
    from_index = units.index(from_unit)
    to_index = units.index(to_unit)
    return value * CONVERSION_FACTORS[from_index] / CONVERSION_FACTORS[to_index]

# テスト
print(is_fibonacci(13))  # True
print(is_fibonacci(15))  # False

print(convert_units(1024, 'MB', 'GB'))  # 1.024
print(convert_units(1.5, 'GB', 'MB'))   # 1536.0

True
False
1.024
1536.0

# タプルを使った定数の定義
DAYS_OF_WEEK = ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday')
CARD_SUITS = ('Hearts', 'Diamonds', 'Clubs', 'Spades')
GEOGRAPHIC_COORDINATES = (35.6895, 139.6917)  # 東京の緯度経度

# namedtupleを使った定数の定義
from collections import namedtuple

RGB = namedtuple('RGB', ['red', 'green', 'blue'])
COLOR_WHITE = RGB(255, 255, 255)
COLOR_BLACK = RGB(0, 0, 0)

# 定数の使用例
def is_weekday(day):
    return day in DAYS_OF_WEEK[:5]

def get_card_color(suit):
    return 'Red' if suit in CARD_SUITS[:2] else 'Black'

def calculate_distance(coord1, coord2):
    return ((coord1[0] - coord2[0])**2 + (coord1[1] - coord2[1])**2)**0.5

def mix_colors(color1, color2):
    return RGB(
        (color1.red + color2.red) // 2,
        (color1.green + color2.green) // 2,
        (color1.blue + color2.blue) // 2
    )

# テスト
print(is_weekday('Saturday'))  # False
print(get_card_color('Hearts'))  # 'Red'
print(calculate_distance(GEOGRAPHIC_COORDINATES, (35.6892, 139.6920)))  # 約0.0003（km）
gray = mix_colors(COLOR_WHITE, COLOR_BLACK)
print(f"Gray: R={gray.red}, G={gray.green}, B={gray.blue}")  # Gray: R=127, G=127, B=127

False
Red
0.0003683439655515412
Gray: R=127, G=127, B=127

PI = 3.14159

def calculate_circle_area(radius):
    PI = 3.14  # 警告：定数の再代入
    return PI * radius ** 2

print(calculate_circle_area(5))  # 78.5（期待値：78.53981633974483）

MAX_VALUE = 100

def process_data(data):
    MAX_VALUE = max(data)  # 警告：グローバル定数と同名のローカル変数
    return [x / MAX_VALUE for x in data]

print(process_data([50, 75, 100, 125]))  # [0.4, 0.6, 0.8, 1.0]

MAX_CONNECTIONS = '100'  # 文字列型で定義

def connect_to_database(num_connections):
    if num_connections <= MAX_CONNECTIONS:  # TypeError: '<=' not supported between instances of 'int' and 'str'
        print("接続成功")
    else:
        print("接続数が上限を超えています")

connect_to_database(50)

MAX_CONNECTIONS: int = 100  # 整数型で定義し、型アノテーションを付ける

def connect_to_database(num_connections: int) -> None:
    if num_connections <= MAX_CONNECTIONS:
        print("接続成功")
    else:
        print("接続数が上限を超えています")

connect_to_database(50)  # 接続成功

{
    "DATABASE": {
        "HOST": "localhost",
        "PORT": 5432,
        "NAME": "myapp_db",
        "USER": "admin",
        "PASSWORD": "secret"
    },
    "API": {
        "BASE_URL": "https://api.example.com",
        "TIMEOUT": 30,
        "MAX_RETRIES": 3
    },
    "FEATURES": {
        "ENABLE_CACHING": true,
        "MAX_CACHE_SIZE": 1000,
        "DEBUG_MODE": false
    }
}

import json
from typing import Any, Dict

class Config:
    _instance = None
    _config: Dict[str, Any] = {}

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._load_config()
        return cls._instance

    def _load_config(self):
        with open('config.json', 'r') as f:
            self._config = json.load(f)

    def get(self, key: str, default: Any = None) -> Any:
        keys = key.split('.')
        value = self._config
        for k in keys:
            if isinstance(value, dict):
                value = value.get(k)
            else:
                return default
        return value if value is not None else default

# 設定の使用例
config = Config()

db_host = config.get('DATABASE.HOST')
api_timeout = config.get('API.TIMEOUT')
debug_mode = config.get('FEATURES.DEBUG_MODE')

print(f"データベースホスト: {db_host}")
print(f"APIタイムアウト: {api_timeout}秒")
print(f"デバッグモード: {'有効' if debug_mode else '無効'}")

# 存在しない設定へのアクセス
unknown_setting = config.get('UNKNOWN.SETTING', 'デフォルト値')
print(f"不明な設定: {unknown_setting}")

データベースホスト: localhost
APIタイムアウト: 30秒
デバッグモード: 無効
不明な設定: デフォルト値

import enum
import logging

class LogLevel(enum.IntEnum):
    DEBUG = logging.DEBUG
    INFO = logging.INFO
    WARNING = logging.WARNING
    ERROR = logging.ERROR
    CRITICAL = logging.CRITICAL

def setup_logger(name: str, level: LogLevel) -> logging.Logger:
    logger = logging.getLogger(name)
    logger.setLevel(level)
    handler = logging.StreamHandler()
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)
    logger.addHandler(handler)
    return logger

# ロガーの使用例
logger = setup_logger("MyApp", LogLevel.INFO)

logger.debug("デバッグメッセージ")  # 出力されない
logger.info("情報メッセージ")
logger.warning("警告メッセージ")
logger.error("エラーメッセージ")
logger.critical("致命的エラーメッセージ")

# ログレベルの変更
logger.setLevel(LogLevel.DEBUG)
logger.debug("デバッグメッセージ（ログレベル変更後）")  # 出力される

2024-08-06 12:34:56,789 - MyApp - INFO - 情報メッセージ
2024-08-06 12:34:56,790 - MyApp - WARNING - 警告メッセージ
2024-08-06 12:34:56,791 - MyApp - ERROR - エラーメッセージ
2024-08-06 12:34:56,792 - MyApp - CRITICAL - 致命的エラーメッセージ
2024-08-06 12:34:56,793 - MyApp - DEBUG - デバッグメッセージ（ログレベル変更後）

import unittest
from typing import List, Tuple

class MathConstants:
    PI = 3.14159
    E = 2.71828

class GeometryCalculator:
    @staticmethod
    def circle_area(radius: float) -> float:
        return MathConstants.PI * radius ** 2

    @staticmethod
    def cylinder_volume(radius: float, height: float) -> float:
        return MathConstants.PI * radius ** 2 * height

class TestGeometryCalculator(unittest.TestCase):
    TEST_CASES: List[Tuple[float, float]] = [
        (1.0, 3.14159),
        (2.0, 12.56636),
        (5.0, 78.53975)
    ]

    def test_circle_area(self):
        for radius, expected_area in self.TEST_CASES:
            with self.subTest(radius=radius):
                calculated_area = GeometryCalculator.circle_area(radius)
                self.assertAlmostEqual(calculated_area, expected_area, places=5)

    def test_cylinder_volume(self):
        HEIGHT = 10.0
        for radius, _ in self.TEST_CASES:
            with self.subTest(radius=radius):
                expected_volume = MathConstants.PI * radius ** 2 * HEIGHT
                calculated_volume = GeometryCalculator.cylinder_volume(radius, HEIGHT)
                self.assertAlmostEqual(calculated_volume, expected_volume, places=5)

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

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

OK