web-dev-qa-db-ja.com

Python：実行時にメソッドと属性を変更する

Pythonで属性とメソッドを追加および削除できるクラスを作成したいのですが、どうすれば達成できますか？

ああ、理由を聞かないでください。

pythonreflectionruntime
70
Migol

Pythonで属性とメソッドを追加および削除できるクラスを作成したい。

import types

class SpecialClass(object):
    @classmethod
    def removeVariable(cls, name):
        return delattr(cls, name)

    @classmethod
    def addMethod(cls, func):
        return setattr(cls, func.__name__, types.MethodType(func, cls))

def hello(self, n):
    print n

instance = SpecialClass()
SpecialClass.addMethod(hello)

>>> SpecialClass.hello(5)
5

>>> instance.hello(6)
6

>>> SpecialClass.removeVariable("hello")

>>> instance.hello(7)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'SpecialClass' object has no attribute 'hello'

>>> SpecialClass.hello(8)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'SpecialClass' has no attribute 'hello'
45
Unknown

この例は、クラスとインスタンスへのメソッドの追加の違いを示しています。

>>> class Dog():
...     def __init__(self, name):
...             self.name = name
...
>>> skip = Dog('Skip')
>>> spot = Dog('Spot')
>>> def talk(self):
...     print 'Hi, my name is ' + self.name
...
>>> Dog.talk = talk # add method to class
>>> skip.talk()
Hi, my name is Skip
>>> spot.talk()
Hi, my name is Spot
>>> del Dog.talk # remove method from class
>>> skip.talk() # won't work anymore
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: Dog instance has no attribute 'talk'
>>> import types
>>> f = types.MethodType(talk, skip, Dog)
>>> skip.talk = f # add method to specific instance
>>> skip.talk()
Hi, my name is Skip
>>> spot.talk() # won't work, since we only modified skip
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: Dog instance has no attribute 'talk'
115
Paolo Bergantino

types.MethodTypeを使用する代わりに興味深い可能性のあるもの：

>>> f = types.MethodType(talk, puppy, Dog)
>>> puppy.talk = f # add method to specific instance

関数が descriptors であるという事実を利用することになります。

>>> puppy.talk = talk.__get__(puppy, Dog)
28
Alex Martelli

Pythonで属性とメソッドを追加および削除できるクラスを作成したいのですが、どうすれば達成できますか？

任意のクラスに対して属性とメソッドを追加および削除できます。これらはクラスのすべてのインスタンスで使用できます。

>>> def method1(self):
       pass

>>> def method1(self):
       print "method1"

>>> def method2(self):
       print "method2"

>>> class C():
       pass

>>> c = C()
>>> c.method()

Traceback (most recent call last):
  File "<pyshell#62>", line 1, in <module>
    c.method()
AttributeError: C instance has no attribute 'method'

>>> C.method = method1
>>> c.method()
    method1
>>> C.method = method2
>>> c.method()
    method2
>>> del C.method
>>> c.method()

Traceback (most recent call last):
  File "<pyshell#68>", line 1, in <module>
    c.method()
AttributeError: C instance has no attribute 'method'
>>> C.attribute = "foo"
>>> c.attribute
    'foo'
>>> c.attribute = "bar"
>>> c.attribute
    'bar'
5
Robert Rossney

クラスに直接割り当てることができます（元のクラス名にアクセスするか、__class__）：

class a : pass
ob=a()
ob.__class__.blah=lambda self,k: (3, self,k)
ob.blah(5)
ob2=a()
ob2.blah(7)

印刷します

(3, <__main__.a instance at 0x7f18e3c345f0>, 5)
(3, <__main__.a instance at 0x7f18e3c344d0>, 7)
4
Johan Lundberg

単に：

f1 = lambda:0                   #method for instances
f2 = lambda _:0                 #method for class
class C: pass                   #class

c1,c2 = C(),C()                 #instances

print dir(c1),dir(c2)

#add to the Instances
c1.func = f1
c1.any = 1.23

print dir(c1),dir(c2)
print c1.func(),c1.any

del c1.func,c1.any

#add to the Class
C.func = f2
C.any = 1.23

print dir(c1),dir(c2)
print c1.func(),c1.any
print c2.func(),c2.any

その結果：

['__doc__', '__module__'] ['__doc__', '__module__']
['__doc__', '__module__', 'any', 'func'] ['__doc__', '__module__']
0 1.23
['__doc__', '__module__', 'any', 'func'] ['__doc__', '__module__', 'any', 'func']
0 1.23
0 1.23
0
Developer

別の代替方法として、クラスの卸売を置き換える必要がある場合は、class属性を変更します。

>>> class A(object):
...     def foo(self):
...         print 'A'
... 
>>> class B(object):
...     def foo(self):
...         print 'Bar'
... 
>>> a = A()
>>> a.foo()
A
>>> a.__class__ = B
>>> a.foo()
Bar
0
Lie Ryan

クラス自体を必ず変更する必要がありますか？または、目的は、実行中の特定の時点でobject.method（）が行うことを単に置き換えることですか？

getattributeとBase継承オブジェクトのRuntime Decoratorを使用して、フレームワーク内の特定のメソッドコールをモンキーパッチに実際に変更する問題を回避するためです。

getattributeのBaseオブジェクトによって取得されたメソッドは、適用するデコレータ/モンキーパッチのキーワード引数を呼び出すメソッドを解析するRuntime_Decoratorにラップされます。

これにより、構文object.method（monkey_patch = "mypatch"）、object.method（decorator = "mydecorator"）、さらにobject.method（decorators = my_decorator_list）を使用できます。

これは個々のメソッド呼び出しに対して機能します（魔法のメソッドは省略します）、実際にはクラス/インスタンス属性を変更せずに行い、任意の外部メソッドを使用してパッチを適用でき、Baseから継承するサブクラスで透過的に動作します（ただし、 getattributeをオーバーライドしません）。

import trace

def monkey_patched(self, *args, **kwargs):
    print self, "Tried to call a method, but it was monkey patched instead"
    return "and now for something completely different"

class Base(object):

    def __init__(self):
        super(Base, self).__init__()

    def testmethod(self):
        print "%s test method" % self

    def __getattribute__(self, attribute):
        value = super(Base, self).__getattribute__(attribute)
        if "__" not in attribute and callable(value):
            value = Runtime_Decorator(value)
        return value

class Runtime_Decorator(object):

    def __init__(self, function):
        self.function = function

    def __call__(self, *args, **kwargs):

        if kwargs.has_key("monkey_patch"):
            module_name, patch_name = self._resolve_string(kwargs.pop("monkey_patch"))
            module = self._get_module(module_name)
            monkey_patch = getattr(module, patch_name)
            return monkey_patch(self.function.im_self, *args, **kwargs)

        if kwargs.has_key('decorator'):
            decorator_type = str(kwargs['decorator'])

            module_name, decorator_name = self._resolve_string(decorator_type)
            decorator = self._get_decorator(decorator_name, module_name)
            wrapped_function = decorator(self.function)
            del kwargs['decorator']
            return wrapped_function(*args, **kwargs)

        Elif kwargs.has_key('decorators'):
            decorators = []

            for item in kwargs['decorators']:
                module_name, decorator_name = self._resolve_string(item)
                decorator = self._get_decorator(decorator_name, module_name)
                decorators.append(decorator)

            wrapped_function = self.function
            for item in reversed(decorators):
                wrapped_function = item(wrapped_function)
            del kwargs['decorators']
            return wrapped_function(*args, **kwargs)

        else:
            return self.function(*args, **kwargs)

    def _resolve_string(self, string):
        try: # attempt to split the string into a module and attribute
            module_name, decorator_name = string.split(".")
        except ValueError: # there was no ".", it's just a single attribute
            module_name = "__main__"
            decorator_name = string
        finally:
            return module_name, decorator_name

    def _get_module(self, module_name):
        try: # attempt to load the module if it exists already
            module = modules[module_name]
        except KeyError: # import it if it doesn't
            module = __import__(module_name)
        finally:
            return module

    def _get_decorator(self, decorator_name, module_name):
        module = self._get_module(module_name)
        try: # attempt to procure the decorator class
            decorator_wrap = getattr(module, decorator_name)
        except AttributeError: # decorator not found in module
            print("failed to locate decorators %s for function %s." %\
            (kwargs["decorator"], self.function))
        else:
            return decorator_wrap # instantiate the class with self.function

class Tracer(object):

    def __init__(self, function):
        self.function = function

    def __call__(self, *args, **kwargs):
        tracer = trace.Trace(trace=1)
        tracer.runfunc(self.function, *args, **kwargs)

b = Base()
b.testmethod(monkey_patch="monkey_patched")
b.testmethod(decorator="Tracer")
#b.testmethod(monkey_patch="external_module.my_patch")

このアプローチの欠点は、getattribute hooksall属性へのアクセスです。そのため、メソッドではない属性は、問題の特定の呼び出しの機能を利用しません。そして、getattributeを使用することは本質的にやや複雑です。

私の経験/目的に対するこのオーバーヘッドの実際の影響はごくわずかであり、マシンはデュアルコアCeleronを実行しています。以前の実装では、オブジェクトで内部観察されたメソッドinitを使用し、Runtime_Decoratorをメソッドにバインドしました。この方法で行うと、getattributeを使用する必要がなくなり、前述のオーバーヘッドが減ります...ただし、ピクルス（おそらくディルではない）が壊れ、このアプローチよりも動的ではありません。

この手法で実際に「実際に」出会った唯一のユースケースは、タイミングデコレータとトレースデコレータに関するものでした。しかし、それが開く可能性は非常に広範囲です。

別のベースから継承することができない既存のクラスがある場合（または、独自のクラス定義またはそのベースクラス内の手法を使用する場合）、残念ながら問題はまったく当てはまりません。

実行時にクラスの呼び出し不可能な属性を設定/削除することは必ずしも難しいとは思いませんか？変更されたクラスから継承するクラスにも自動的に変更が反映されるようにしたい場合を除きます。

0
Ella Rose