2

我正在解决python koans。直到 34 号，我才遇到任何真正的问题。

这就是问题：

项目：创建代理类

在这个作业中，创建一个代理类（下面为您启动一个）。您应该能够使用任何对象初始化代理对象。代理对象上调用的任何属性都应该转发给目标对象。在发送每个属性调用时，代理应该记录发送的属性的名称。

代理类已为您启动。您将需要添加一个缺少处理程序的方法和任何其他支持方法。代理类的规范在 AboutProxyObjectProject 公文中给出。

注意：这有点棘手，它是 Ruby Koans 对应物，但你可以做到！

到目前为止，这是我的解决方案：

class Proxy(object):
    def __init__(self, target_object):
        self._count = {}
        #initialize '_obj' attribute last. Trust me on this!
        self._obj = target_object

    def __setattr__(self, name, value):pass


    def __getattr__(self, attr):
        if attr in self._count: 
            self._count[attr]+=1
        else: 
            self._count[attr]=1
        return getattr(self._obj, attr)

    def messages(self):
        return self._count.keys()

    def was_called(self, attr):
        if attr in self._count:
            return True
        else: False

    def number_of_times_called(self, attr):
        if attr in self._count:
            return self._count[attr]
        else: return False

在此测试之前它一直有效：

def test_proxy_records_messages_sent_to_tv(self):
    tv = Proxy(Television())

    tv.power()
    tv.channel = 10

    self.assertEqual(['power', 'channel='], tv.messages())

因为tv.messages()是由代理对象而不是电视对象获取的['power']。 我试图操纵该方法，但我总是以无限循环结束。tv.channel=10
__setattr__

编辑1：

我正在尝试这个：

def __setattr__(self, name, value):
        if hasattr(self, name):
            object.__setattr__(self,name,value)
        else: 
            object.__setattr__(self._obj, name, value)

但是后来我在最后一个条目的循环中得到了这个错误：

RuntimeError: maximum recursion depth exceeded while calling a Python object


File "/home/kurojishi/programmi/python_koans/python 2/koans/about_proxy_object_project.py", line 60, in test_proxy_method_returns_wrapped_object
tv = Proxy(Television())                                                                                                                                     
File "/home/kurojishi/programmi/python_koans/python 2/koans/about_proxy_object_project.py", line 25, in __init__                                               
self._count = {}                                                                                                                                             
File "/home/kurojishi/programmi/python_koans/python 2/koans/about_proxy_object_project.py", line 33, in __setattr__                                            
object.__setattr__(self._obj, name, value)                                                                                                                   
File "/home/kurojishi/programmi/python_koans/python 2/koans/about_proxy_object_project.py", line 36, in __getattr__                                            
if attr in self._count:

循环在__getattr__.

4

7 回答 7

6

您正在使用hasattrin__setattr__来决定是否应该写入本地对象或代理对象。这适用于除一种情况外的所有情况。

在你的__init__你有以下行：

  self._count = {}

this 调用which 在该点__setattr__上'_count'不存在，因此（因此hasattr返回False）被转发到代理对象。

如果你想使用你的方法，你必须这样写__init__：

def __init__(self, target_object):
    object.__setattr__(self, '_count', {})
    #initialize '_obj' attribute last. Trust me on this!
    object.__setattr__(self, '_obj', target_object)
于 2012-06-19T08:17:14.943 回答
4

据我了解，您的问题可能与设置和属性值时的递归调用有关。来自文档：

如果__setattr__()要分配给一个实例属性，它不应该简单地执行“ self.name = value”——这将导致对其自身的递归调用。相反，它应该在实例属性字典中插入值，例如“ self.__dict__[name] = value”。对于新式类，它应该调用具有相同名称的基类方法，而不是访问实例字典，例如“ object.__setattr__(self, name, value)”。

于 2011-12-18T20:40:50.123 回答
1

从测试来看，代理需要通过代理记录所有属性调用。而且代理只有很少的内置方法特别用于日志记录，所以我的回答是：

class Proxy(object):

    def __init__(self, target_object):
        self.logs=[]
        self._obj = target_object


    def __getattribute__(self, attrname):
        if attrname in ['_obj','logs','messages','was_called','number_of_times_called'] :
            return object.__getattribute__(self, attrname)
        else:
            self.logs.append(attrname)
            return object.__getattribute__((object.__getattribute__(self, '_obj')), attrname)


    def __setattr__(self, name, value):
        if hasattr(self, '_obj'):
            self.logs.append(name)
            object.__setattr__(object.__getattribute__(self,'_obj'), name, value)
        else :
            object.__setattr__(self, name, value)

在此之后，很容易实现其他方法（'messages'，'was_call'，...）

对不起，老问题。

我发现getattribute可以更改：只需检查属性是否在目标对象中。

def __getattribute__(self, attrname):
        if attrname not in dir(object.__getattribute__(self, '_obj')):
            return object.__getattribute__(self, attrname)
        else:
            self.logs.append(attrname)
            return object.__getattribute__((object.__getattribute__(self, '_obj')), attrname)
于 2012-10-05T03:15:22.623 回答
1

setattr 在所有分配上都被调用。它更像是 getattribute 而不是 getattr。这也会影响 __init__ 方法中的代码。

这意味着这段代码的第一个分支几乎总是会失败，只有从 object 继承的属性才能通过测试：

def __setattr__(self, name, value):
    if hasattr(self, name):
        object.__setattr__(self,name,value)
    else: 
        object.__setattr__(self._obj, name, value)

相反，我们可以假设分配是针对代理的，除非它具有 _obj 属性。因此 __init__ 中的注释。我们设置代理的属性，然后添加目标对象并将所有未来的分配发送给它。

def __setattr__(self, name, value):
    if hasattr(self, '_obj'):
        object.__setattr__(self._obj, name, value)
    else:
        object.__setattr__(self, name, value)

但是通过使用 hasattr，我们还需要更改 __getattr__ 以检查 _obj 以防止递归：

def __getattr__(self, name):
    if '_obj' == name:
        raise AttributeError

    if attr in self._count: 
        self._count[attr]+=1
    else: 
        self._count[attr]=1
    return getattr(self._obj, attr)

另一种方法是直接在 __setattr__ 方法中检查代理的 __dict__ 属性：

def __setattr__(self, name, value):
    if '_obj' in self.__dict__:
    ...
于 2012-01-11T21:34:05.483 回答
0

我所做的是对代理中的属性进行所有调用并通过调用它们object.__getattribute__以避免递归。

这对方法不起作用，所以我将方法调用包装在 try..except AttributeError 中，以便首先在代理中尝试它们。然后如果他们引发错误，请在子对象中尝试它们。

如果有人有更优雅的解决方案会很乐意看到它。

从 runner.koan 导入 *
从集合导入计数器

类代理（对象）：
    def __init__(self, target_object):
        self._messages=[]
        self._obj = target_object

    def 消息（自我）：
        返回 self._messages

    def 被调用（自我，消息）：
        在 self._messages 中返回消息

    def number_of_times_called(self, message):
        _count = Counter(self._messages).get(message)
        如果_count：
            返回_count
        else: # 捕捉无
            返回 0

    def __getattribute__(self, attr_name):
        try: # 调用自身
            retval = object.__getattribute__(self, attr_name)
        除了 AttributeError: # 调用子对象
            retval = self._obj.__getattribute__(attr_name)
            object.__getattribute__(self, '_messages').append(attr_name)

        返回值

    def __setattr__(self, attr_name, attr_value):
        if hasattr(self, '_obj'): # 调用子对象并记录消息
            self._obj.__setattr__(attr_name, attr_value)
            attr_name += "="
            object.__getattribute__(self, '_messages').append(attr_name)
        else: # use this before_obj 在 __init__ 中设置
            object.__setattr__(self, attr_name, attr_value)

    def 消息（自我）：
        返回 self._messages
于 2012-06-03T03:02:17.217 回答
0 
class Proxy(object):
   """Proxy class wraps any other class, and adds functionality to remember and report all messages called.
Limitations include that proxy blocks all direct subclass calls to:
messages, number_of_times_called, was_called, _obj, and _message_counts.
These calls must be made directly like my_proxy_instance._obj.messages.
"""


def __init__(self, target_object):
    print 'initializing a proxy for ' + target_object.__class__.__name__
    # WRITE CODE HERE
    self._message_counts = Counter();
    #initialize '_obj' attribute last. Trust me on this!
    self._obj = target_object

# WRITE CODE HERE                                   
def  __getattr__(self, attr_name):
    print 'getting an attribute: "' + attr_name + '" from "' + self._obj.__class__.__name__  + '"'
    self._message_counts[attr_name] += 1
    print self._message_counts
    return object.__getattribute__(self._obj, attr_name)

#def __getattribute__(self, attr_name):
#    print "intercepted!~ " + attr_name
#    object.__getattribute__(self, attr_name)

def __setattr__(self, attr_name, value):
    if((attr_name == '_obj') | (attr_name == '_message_counts')): # special proxy attributes.
        print 'setting the PROXY attribute: "' + attr_name + '"'
        object.__setattr__(self, attr_name, value)
    else:
        print 'setting the REAL attribute: "' + attr_name + '"'
        self._message_counts[attr_name+"="] += 1
        object.__setattr__(self._obj, attr_name, value)

def messages(self):
    return self._message_counts.keys()

def number_of_times_called(self, attr_name):
    return self._message_counts[attr_name]

def was_called(self, attr_name):
    return attr_name in self._message_counts
于 2012-02-04T02:16:33.433 回答
0

为什么不使用method_missing？
我的答案：

class Proxy
  def initialize(target_object)
    @object = target_object
    # ADD MORE CODE HERE
    @messages = []
  end

  # WRITE CODE HERE
  def method_missing(method_name, *args, &block)
    @messages.push method_name unless method_name == :messages
    @object.send method_name, *args, &block
  end
  def messages
    @messages
  end
  def called? target
    @messages.include? target
  end
  def number_of_times_called target
    result = 0
    @messages.each do |t|
      result += 1 if t == target
    end
    result
  end
end
于 2021-01-20T01:43:35.627 回答