Pythonメタプログラミング：動的なコード生成と実行時の修正

            class MyMeta(type):
 def __new__(cls, name, bases, attrs):
 attrs['attribute_added_by_metaclass'] = 'Hello from MyMeta!'
 return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=MyMeta):
 pass

obj = MyClass()
print(obj.attribute_added_by_metaclass)  # Output: Hello from MyMeta!

            

              
                Copy
              
            
          

            class StringAttributeMeta(type):
 def __new__(cls, name, bases, attrs):
 for attr_name, attr_value in attrs.items():
 if not attr_name.startswith('__') and not isinstance(attr_value, str):
 raise TypeError(f"Attribute '{attr_name}' must be a string")
 return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=StringAttributeMeta):
 name = "John Doe"
 age = 30 # This will raise a TypeError

            

              
                Copy
              
            
          

            import time

def timer(func):
 def wrapper(*args, **kwargs):
 start_time = time.time()
 result = func(*args, **kwargs)
 end_time = time.time()
 print(f"Function '{func.__name__}' took {end_time - start_time:.4f} seconds")
 return result
 return wrapper

@timer
def my_function():
 time.sleep(1)

my_function()

            

              
                Copy
              
            
          

            def add_method(method):
 def decorator(cls):
 setattr(cls, method.__name__, method)
 return cls
 return decorator

def my_new_method(self):
 print("This method was added by a decorator!")

@add_method(my_new_method)
class MyClass:
 pass

obj = MyClass()
obj.my_new_method()  # Output: This method was added by a decorator!

            

              
                Copy
              
            
          

            x = 5
print(type(x))  # Output: <class 'int'>

            

              
                Copy
              
            
          

            class MyClass:
 def __init__(self):
 self.name = "John"

obj = MyClass()
print(dir(obj))
# Output: ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']

            

              
                Copy
              
            
          

            class MyClass:
 def __init__(self):
 self.name = "John"

obj = MyClass()

if hasattr(obj, 'name'):
 print(getattr(obj, 'name'))  # Output: John

if hasattr(obj, 'age'):
 print(getattr(obj, 'age'))
else:
 print("Object does not have age attribute") # Output: Object does not have age attribute

            

              
                Copy
              
            
          

            import inspect

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

source_code = inspect.getsource(my_function)
print(source_code)
# Output:
# def my_function(a, b):
# return a + b

signature = inspect.signature(my_function)
print(signature) # Output: (a, b)

            

              
                Copy
              
            
          

            class MyClass:
 pass

obj = MyClass()
obj.new_attribute = "This is a new attribute"

print(obj.new_attribute)  # Output: This is a new attribute

            

              
                Copy
              
            
          

            class MyClass:
 def __init__(self):
 self.name = "John"

obj = MyClass()
obj.name = "Jane"

print(obj.name)  # Output: Jane

            

              
                Copy
              
            
          

            class MyClass:
 def __init__(self):
 self.name = "John"

obj = MyClass()
setattr(obj, 'age', 30)
print(obj.age)  # Output: 30

delattr(obj, 'name')

if hasattr(obj, 'name'):
 print(obj.name)
else:
 print("Object does not have name attribute") # Output: Object does not have name attribute

            

              
                Copy
              
            
          

            def generate_class(class_name, attributes):
 code = f"class {class_name}:\n"
 code += " def __init__(self, " + ", ".join(attributes) + "):\n"
 for attr in attributes:
 code += f" self.{attr} = {attr}\n"
 return code

class_code = generate_class("MyGeneratedClass", ["name", "age"])
print(class_code)
# Output:
# class MyGeneratedClass:
# def __init__(self, name, age):
# self.name = name
# self.age = age

exec(class_code)

obj = MyGeneratedClass("John", 30)
print(obj.name, obj.age) # Output: John 30

            

              
                Copy
              
            
          

            from string import Template

def generate_class_from_template(class_name, attributes):
 template = Template("""
class $class_name:
 def __init__(self, $attributes):
 $attribute_assignments
""")

 attribute_string = ", ".join(attributes)
 attribute_assignments = "\n".join([f" self.{attr} = {attr}" for attr in attributes])

 code = template.substitute(class_name=class_name, attributes=attribute_string, attribute_assignments=attribute_assignments)
 return code

class_code = generate_class_from_template("MyTemplatedClass", ["name", "age"])
print(class_code)
# Output:
# class MyTemplatedClass:
# def __init__(self, name, age):
# self.name = name
# self.age = age

exec(class_code)

obj = MyTemplatedClass("John", 30)
print(obj.name, obj.age)

            

              
                Copy
              
            
          

            class MyClass:
 def my_method(self):
 print("Original method")

def new_method(self):
 print("Monkey-patched method")

MyClass.my_method = new_method

obj = MyClass()
obj.my_method()  # Output: Monkey-patched method

            

              
                Copy
              
            
          

            import math

def my_sqrt(x):
 return x / 2  # Incorrect implementation for demonstration purposes

math.sqrt = my_sqrt

print(math.sqrt(4))  # Output: 2.0

            

              
                Copy
              
            
          

            import json

def create_api_client(api_spec_path):
 with open(api_spec_path, 'r') as f:
 api_spec = json.load(f)

 class_name = api_spec['title'].replace(' ', '') + 'Client'

 class_attributes = {}
 for path, path_data in api_spec['paths'].items():
 for method, method_data in path_data.items():
 operation_id = method_data['operationId']

 def api_method(self, *args, **kwargs):
 # Placeholder for API call logic
 print(f"Calling {method.upper()} {path} with args: {args}, kwargs: {kwargs}")
 # Simulate API response
 return {"message": f"{operation_id} executed successfully"}

 api_method.__name__ = operation_id # Set dynamic method name
 class_attributes[operation_id] = api_method

 ApiClient = type(class_name, (object,), class_attributes) # Dynamically create the class
 return ApiClient

# Example API Specification (simplified)
api_spec_data = {
 "title": "My Awesome API",
 "paths": {
 "/users": {
 "get": {
 "operationId": "getUsers"
 },
 "post": {
 "operationId": "createUser"
 }
 },
 "/products": {
 "get": {
 "operationId": "getProducts"
 }
 }
 }
}

api_spec_path = "api_spec.json" # Create a dummy file for testing
with open(api_spec_path, 'w') as f:
 json.dump(api_spec_data, f)

ApiClient = create_api_client(api_spec_path)
client = ApiClient()
print(client.getUsers())
print(client.createUser(name="New User", email="new@example.com"))
print(client.getProducts())

            

              
                Copy