Pythonで動的にオブジェクトを生成する10の方法

my_string = "Hello, World!"
print(my_string.upper())  # 出力: HELLO, WORLD!

string1 = "Hello"
string2 = "World"
print(string1)  # 出力: Hello
print(string2)  # 出力: World

def create_class(name):
    return type(name, (), {})

MyClass = create_class("MyClass")
my_object = MyClass()
print(type(my_object))  # 出力: <class '__main__.MyClass'>

class StaticClass:
    def __init__(self, name):
        self.name = name

static_object = StaticClass("Static")
print(static_object.name)  # 出力: Static

DynamicClass = type("DynamicClass", (), {"name": "Dynamic"})
dynamic_object = DynamicClass()
print(dynamic_object.name)  # 出力: Dynamic

# type()関数を使ってクラスを動的に生成
MyClass = type('MyClass', (), {'my_method': lambda self: print("Hello from MyClass!")})

# 生成したクラスのインスタンスを作成
my_instance = MyClass()

# メソッドを呼び出す
my_instance.my_method()

def create_class(name, attributes):
    return type(name, (), attributes)

# クラスを動的に生成
MyClass = create_class('MyClass', {'greeting': lambda self: print(f"Hello from {self.__class__.__name__}!")})

# インスタンスを作成
my_instance = MyClass()

# メソッドを呼び出す
my_instance.greeting()

class MyMetaclass(type):
    def __new__(cls, name, bases, attrs):
        # クラス名を大文字に変換
        name = name.upper()
        # 全てのメソッド名の先頭に 'my_' を追加
        attrs = {'my_' + key: value for key, value in attrs.items() if not key.startswith('__')}
        return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=MyMetaclass):
    def hello(self):
        print("Hello from MyClass!")

# インスタンスを作成
my_instance = MyClass()

# メソッドを呼び出す
my_instance.my_hello()

# クラス名を確認
print(MyClass.__name__)

Hello from MyClass!
MYCLASS

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            print("Creating the object")
            cls._instance = super().__new__(cls)
        return cls._instance

# インスタンスを生成
s1 = Singleton()
s2 = Singleton()

# 同じオブジェクトであることを確認
print(s1 is s2)

Creating the object
True

class DynamicObject:
    pass

# インスタンスを生成
obj = DynamicObject()

# 動的に属性を追加
obj.name = "Dynamic Object"
obj.greet = lambda: print(f"Hello, I'm {obj.name}!")

# 追加した属性とメソッドを使用
print(obj.name)
obj.greet()

Dynamic Object
Hello, I'm Dynamic Object!

import importlib

# 動的にモジュールをインポート
math_module = importlib.import_module('math')

# インポートしたモジュールの関数を使用
result = math_module.sqrt(16)
print(f"The square root of 16 is: {result}")

# 動的に実行するコード
code = """
class DynamicClass:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"Hello, I'm {self.name}!")

# クラスのインスタンスを作成
obj = DynamicClass("Dynamic Instance")
obj.greet()
"""

# コードを実行
exec(code)

from functools import partial

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

# 部分適用を使用して新しい関数を作成
hello_greet = partial(greet, "Hello")
hi_greet = partial(greet, "Hi")

# 新しい関数を使用
print(hello_greet("Alice"))
print(hi_greet("Bob"))

Hello, Alice!
Hi, Bob!

from operator import attrgetter

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# Personオブジェクトのリストを作成
people = [
    Person("Alice", 30),
    Person("Bob", 25),
    Person("Charlie", 35)
]

# nameとageを取得する関数を作成
get_name = attrgetter('name')
get_age = attrgetter('age')

# 関数を使用してソート
sorted_by_name = sorted(people, key=get_name)
sorted_by_age = sorted(people, key=get_age)

# 結果を表示
print("Sorted by name:")
for person in sorted_by_name:
    print(f"{get_name(person)}: {get_age(person)}")

print("\nSorted by age:")
for person in sorted_by_age:
    print(f"{get_name(person)}: {get_age(person)}")

Sorted by name:
Alice: 30
Bob: 25
Charlie: 35

Sorted by age:
Bob: 25
Alice: 30
Charlie: 35

from collections import namedtuple

# Pointという名前のnamedtupleを作成
Point = namedtuple('Point', ['x', 'y'])

# Pointオブジェクトを生成
p = Point(1, 2)

# 属性にアクセス
print(f"X coordinate: {p.x}")
print(f"Y coordinate: {p.y}")

# タプルとしてアンパック
x, y = p
print(f"Unpacked coordinates: ({x}, {y})")

# イミュータブルであることを確認
try:
    p.x = 3
except AttributeError as e:
    print(f"Error: {e}")

X coordinate: 1
Y coordinate: 2
Unpacked coordinates: (1, 2)
Error: can't set attribute

import importlib
import os

class PluginManager:
    def __init__(self, plugin_dir):
        self.plugin_dir = plugin_dir
        self.plugins = {}

    def load_plugins(self):
        for filename in os.listdir(self.plugin_dir):
            if filename.endswith('.py') and not filename.startswith('__'):
                module_name = filename[:-3]  # .pyを除いたファイル名
                module = importlib.import_module(f'plugins.{module_name}')
                if hasattr(module, 'Plugin'):
                    plugin_class = getattr(module, 'Plugin')
                    plugin_instance = plugin_class()
                    self.plugins[module_name] = plugin_instance

    def execute_plugin(self, plugin_name, *args, **kwargs):
        if plugin_name in self.plugins:
            return self.plugins[plugin_name].execute(*args, **kwargs)
        else:
            raise ValueError(f"Plugin '{plugin_name}' not found")

# プラグインの使用例
if __name__ == "__main__":
    manager = PluginManager("plugins")
    manager.load_plugins()

    result = manager.execute_plugin("example_plugin", "Hello from main!")
    print(result)

class Plugin:
    def execute(self, message):
        return f"Example Plugin received: {message}"

import yaml
import importlib

def create_object_from_config(config):
    module_name, class_name = config['class'].rsplit('.', 1)
    module = importlib.import_module(module_name)
    class_ = getattr(module, class_name)

    if 'args' in config:
        return class_(**config['args'])
    else:
        return class_()

# 設定ファイルの読み込み
with open('config.yaml', 'r') as file:
    config = yaml.safe_load(file)

# オブジェクトの生成
objects = {}
for key, value in config['objects'].items():
    objects[key] = create_object_from_config(value)

# オブジェクトの使用
for key, obj in objects.items():
    print(f"{key}: {obj.process()}")

objects:
  processor1:
    class: myapp.processors.TextProcessor
    args:
      language: 'en'
  processor2:
    class: myapp.processors.ImageProcessor
    args:
      format: 'jpg'

processor1: Processing text in English
processor2: Processing JPG image

import unittest

def create_test_case(test_name, input_value, expected_output):
    def test_method(self):
        result = self.function_under_test(input_value)
        self.assertEqual(result, expected_output)

    return type(test_name, (unittest.TestCase,), {
        'test_method': test_method,
        'function_under_test': staticmethod(lambda x: x * 2)  # テスト対象の関数
    })

# テストケースの定義
test_cases = [
    ('TestDouble2', 2, 4),
    ('TestDouble3', 3, 6),
    ('TestDouble5', 5, 10),
]

# テストスイートの作成
suite = unittest.TestSuite()

for test_name, input_value, expected_output in test_cases:
    TestCase = create_test_case(test_name, input_value, expected_output)
    suite.addTest(TestCase('test_method'))

# テストの実行
runner = unittest.TextTestRunner()
runner.run(suite)

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

OK

class DynamicClass:
    pass

obj = DynamicClass()
print(obj.non_existent_attribute)

class DynamicClass:
    pass

obj = DynamicClass()

# hasattr()を使用して属性の存在を確認
if hasattr(obj, 'non_existent_attribute'):
    print(obj.non_existent_attribute)
else:
    print("属性が存在しません")

# getattr()を使用してデフォルト値を設定
value = getattr(obj, 'non_existent_attribute', 'デフォルト値')
print(value)

属性が存在しません
デフォルト値

def dynamic_operation(obj):
    return obj + 5

# 整数でテスト
print(dynamic_operation(10))

# 文字列でテスト
print(dynamic_operation("Hello"))

15
TypeError: can only concatenate str (not "int") to str

def dynamic_operation(obj):
    if isinstance(obj, int):
        return obj + 5
    elif isinstance(obj, str):
        return obj + " World"
    else:
        raise TypeError("サポートされていない型です")

# 整数でテスト
print(dynamic_operation(10))

# 文字列でテスト
print(dynamic_operation("Hello"))

# サポートされていない型でテスト
try:
    print(dynamic_operation([1, 2, 3]))
except TypeError as e:
    print(f"エラー: {e}")

15
Hello World
エラー: サポートされていない型です

def create_dynamic_class(class_name):
    globals()[class_name] = type(class_name, (), {})

# 動的にクラスを作成
create_dynamic_class("DynamicClass")

# 作成したクラスをインスタンス化
obj = DynamicClass()

# 存在しないクラスをインスタンス化しようとする
obj2 = NonExistentClass()

def create_dynamic_class(class_name):
    globals()[class_name] = type(class_name, (), {})

# 動的にクラスを作成
create_dynamic_class("DynamicClass")

# 作成したクラスをインスタンス化
if "DynamicClass" in globals():
    obj = globals()["DynamicClass"]()
    print("DynamicClassのインスタンスを作成しました")
else:
    print("DynamicClassが定義されていません")

# 存在しないクラスをインスタンス化しようとする
if "NonExistentClass" in globals():
    obj2 = globals()["NonExistentClass"]()
else:
    print("NonExistentClassが定義されていません")

DynamicClassのインスタンスを作成しました
NonExistentClassが定義されていません

class ClassFactory:
    _cache = {}

    @classmethod
    def create(cls, name, *args, **kwargs):
        if name not in cls._cache:
            cls._cache[name] = type(name, *args, **kwargs)
        return cls._cache[name]

# クラスの動的生成
MyClass1 = ClassFactory.create('MyClass1', (), {'method': lambda self: print("Hello")})
MyClass2 = ClassFactory.create('MyClass2', (), {'method': lambda self: print("World")})

# 同じ名前のクラスを再度生成（キャッシュから取得）
MyClass1Again = ClassFactory.create('MyClass1', (), {})

# 生成されたクラスの使用
MyClass1().method()
MyClass2().method()
MyClass1Again().method()

Hello
World
Hello

ALLOWED_CLASSES = {
    'StringProcessor': str,
    'ListProcessor': list,
    'DictProcessor': dict
}

def safe_create_object(class_name, *args, **kwargs):
    if class_name not in ALLOWED_CLASSES:
        raise ValueError(f"クラス '{class_name}' は許可されていません")
    return ALLOWED_CLASSES[class_name](*args, **kwargs)

# 安全なオブジェクト生成
try:
    obj1 = safe_create_object('StringProcessor', 'Hello, World!')
    print(obj1)

    obj2 = safe_create_object('ListProcessor', [1, 2, 3])
    print(obj2)

    obj3 = safe_create_object('DangerousClass')
except ValueError as e:
    print(f"エラー: {e}")

Hello, World!
[1, 2, 3]
エラー: クラス 'DangerousClass' は許可されていません

def create_model_class(name, fields):
    """
    動的にモデルクラスを生成する関数

    Parameters:
    name (str): 生成するクラスの名前
    fields (dict): クラスのフィールド。キーがフィールド名、値がフィールドの型。

    Returns:
    type: 生成されたモデルクラス

    生成されるクラスの構造:
    class <name>:
        def __init__(self, **kwargs):
            # フィールドの初期化

        def __repr__(self):
            # オブジェクトの文字列表現を返す

        # 各フィールドに対するgetter/setterメソッド
    """
    def __init__(self, **kwargs):
        for field, field_type in fields.items():
            setattr(self, field, kwargs.get(field, None))

    def __repr__(self):
        fields_str = ', '.join(f"{f}={getattr(self, f)}" for f in fields)
        return f"{name}({fields_str})"

    class_dict = {
        '__init__': __init__,
        '__repr__': __repr__
    }

    # getter/setterメソッドの追加
    for field in fields:
        class_dict[f'get_{field}'] = lambda self, f=field: getattr(self, f)
        class_dict[f'set_{field}'] = lambda self, value, f=field: setattr(self, f, value)

    return type(name, (), class_dict)

# 動的クラスの生成
User = create_model_class('User', {'name': str, 'age': int})

# 生成されたクラスの使用
user = User(name="Alice", age=30)
print(user)
print(user.get_name())
user.set_age(31)
print(user)

User(name=Alice, age=30)
Alice
User(name=Alice, age=31)