Что такое эквивалент Python метода Ruby method_missing
? Я попытался использовать __getattr__
, но этот крючок относится и к полям. Я просто хочу перехватить вызовы метода. Что такое способ Python?
Python эквивалент Ruby 'method_missing'
Ответ 1
В Python нет различий между свойствами и методами. Метод - это просто свойство, тип которого просто instancemethod
, который оказывается вызываемым (поддерживает __call__
).
Если вы хотите реализовать это, ваш метод __getattr__
должен вернуть функцию (a lambda
или обычный def
, любой набор ваших потребностей) и, возможно, проверить что-то после вызова.
Ответ 2
Python не различает методы и атрибуты (переменные экземпляра "a.k.a." ), как это делает Ruby. Методы и другие атрибуты объектов просматриваются точно так же в Python - даже Python не знает разницы на этапе поиска. Пока атрибут не найден, это просто строка.
Итак, если вы просите о способе гарантировать, что __getattr__
вызван только для методов, я боюсь, что вы, вероятно, не найдете элегантного решения. Но достаточно просто просто вернуть функцию (или даже новый динамически связанный метод) из __getattr__
.
Ответ 3
Вы можете реализовать функцию missing_method, как показано ниже:
https://gist.github.com/gterzian/6400170
import unittest
from functools import partial
class MethodMissing:
def method_missing(self, name, *args, **kwargs):
'''please implement'''
raise NotImplementedError('please implement a "method_missing" method')
def __getattr__(self, name):
return partial(self.method_missing, name)
class Wrapper(object, MethodMissing):
def __init__(self, item):
self.item = item
def method_missing(self, name, *args, **kwargs):
if name in dir(self.item):
method = getattr(self.item, name)
if callable(method):
return method(*args, **kwargs)
else:
raise AttributeError(' %s has not method named "%s" ' % (self.item, name))
class Item(object):
def __init__(self, name):
self.name = name
def test(self, string):
return string + ' was passed on'
class EmptyWrapper(object, MethodMissing):
'''not implementing a missing_method'''
pass
class TestWrapper(unittest.TestCase):
def setUp(self):
self.item = Item('test')
self.wrapper = Wrapper(self.item)
self.empty_wrapper = EmptyWrapper()
def test_proxy_method_call(self):
string = self.wrapper.test('message')
self.assertEqual(string, 'message was passed on')
def test_normal_attribute_not_proxied(self, ):
with self.assertRaises(AttributeError):
self.wrapper.name
self.wrapper.name()
def test_empty_wrapper_raises_error(self, ):
with self.assertRaises(NotImplementedError):
self.empty_wrapper.test('message')
if __name__ == '__main__':
unittest.main()
Ответ 4
Хотя я не рекомендую его!!!!!!!!!!!!!!!!!!!!!
этот подход приближается к реализации поведения вызова специального метода для каждого имени, которое не соответствует вызываемому атрибуту/методу. Конечно, у них по-прежнему нет отдельных пространств имен, поэтому может показаться немного странным. Он работает, переопределяя __getattribute__
, который работает на более низком уровне, а затем __getattr__
пытается извлечь атрибут, если он терпит неудачу, он возвращает специальный метод, который вызывается с помощью имени, с которым вы его назвали, если он преуспевает, он передает его, если его в противном случае
завершает результат с помощью прокси-объекта, который действует почти точно так же, как потом, за исключением того, что он выполняет вызов с помощью специального метода.
Это не позволяет вам получить доступ к вызывающему объекту, потому что я не мог придумать, как это сделать, без какой-либо утечки памяти (вызывающего объекта), если он уже является атрибутом, не подлежащим вызову, который вы храните ( только думаю, что я могу думать о том, чтобы начать новый поток, который удаляет его через минуту, к тому времени вы предположительно вызвали его, если вы не используете его в закрытии, которое в этом случае не поддерживается).
Изменить: я забыл, что вызываемый может иметь некоторые ложные срабатывания.
зависит от http://pypi.python.org/pypi/ProxyTypes библиотека
from peak.util.proxies import ObjectWrapper
from functools import partial
def m(name, *args, **kwargs):
print(name,repr(args),repr(kwargs))
class CallProxy(ObjectWrapper):
def __init__(self, obj, m, method_name):
ObjectWrapper.__init__(self, obj)
object.__setattr__(self, "_method_name", method_name)
object.__setattr__(self, "_m", m)
def __call__(self, *args, **kwargs):
return self._m(self._method_name, *args,**kwargs)
class Y(object):
def __init__(self):
self.x = [3]
def __getattribute__(self, name):
try:
val = object.__getattribute__(self, name)
if not callable(val):
return CallProxy(val, m, name)
else:
return val
except AttributeError:
return partial(m, name)
In [2]: y=Y()
In [3]: y.x
Out[3]: [3]
In [4]: y.z
Out[4]: <functools.partial at 0x2667890>
In [5]: y.zz([12])
('zz', '([12],)', '{}')
In [6]: y.x.append(5)
In [7]: y.x
Out[7]: [3, 5]
In [8]: y.x(1,2,3,key="no")
('x', '(2, 3)', "{'key': 'no'}")