1

我想实现一些像这样工作的东西：

memo = Note("memo",5)
report = Note("report",20)

notebook = Notebook(memo,report)

print str(notebook.memo) # 5 expected
print str(notebook.report) # 20 expected

灵感来自：http: //znasibov.info/blog/html/2010/03/10/python-classes-dynamic-properties.html 和 How to implement property() with dynamic name (in python) ，我实现了以下代码：

class Note:
    def __init__(self,name,size):
        self.name = name
        self.size = size

class Notebook(object):
    def __new__(cls,*notes):
        notebook = object.__new__(cls)
        setattr(notebook,'_notes',{note.name : note.size for note in notes})
        functions = [lambda notebook : notebook._notes[note.name] for note in notes]
        for note,function in zip(notes,functions) :
            #version 1
            setattr(notebook.__class__, note.name, property(function))
            #version 2 -- note : __class__ removed
            #setattr(notebook, note.name, property(function))
        return notebook

注意：我知道对于这个最小的代码使用__new__代替__init__是不合理的，但是稍后当我使用的子类时需要这样做Notebook

如果我使用版本 1: 1. 而不是拥有5和20被打印，它会打印20和20. 我不明白为什么。打印函数会显示具有不同地址的函数数组。2. 我使用__class__了上面给出的博客条目的启发，但我不确定它的作用。它使属性成为类属性？（在我的情况下这将是非常糟糕的）

如果我使用版本 2：打印类似property object at 0x7fb86a9d9b50. 这似乎是有道理的，但我不确定我是否理解为什么它不会为版本 1 打印相同的内容。

有没有办法解决这个问题，使用任一版本（或另一种完全不同的方法）？

编辑

提出了解决该问题的有趣答案。这里对应的代码：

class Note:
    def __init__(self,name,value):
        self.name = name
        self.size = value
    def _get_size(self,notebook_class=None): return self.size+1

class Notebook(object):
    def __new__(cls,*notes):
        notebook = object.__new__(cls)
        notebook._notes = {note.name : note.size for note in notes}
        for note in notes : setattr(notebook.__class__, note.name, property(note._get_size))
        return notebook

问题是：现在这个测试代码没有给出想要的输出：

memo1 = Note("memo",5)
report1 = Note("report",20)
notebook1 = Notebook(memo1,report1)
print str(notebook1.memo) # print 6 as expected (function of Note return size+1)
print str(notebook1.report) # print 21 as expected

memo2 = Note("memo",35)
report2 = Note("report",40)
notebook2 = Notebook(memo2,report2)
print str(notebook2.memo) # print 36 as expected
print str(notebook2.report) # print 41 expected

print str(notebook1.memo) # does not print 6 but 36 !
print str(notebook1.report) # does not print 21 but 41 !

我想这是可以预料的，因为该属性已添加到课程中……无论如何要克服这个问题？

4

2 回答 2

1

在循环中创建函数很棘手：

>>> lambdas = [(lambda: i) for i in range(5)]
>>> for lamb in lambdas:
...     print(lamb())
... 
4
4
4
4
4

请注意，所有lambdas 指的是i在最后一次迭代中假定的值。当你创建一个函数时，python 会为它关联一个闭包，它告诉解释器该函数应该使用哪些非局部变量：

>>> lambdas[0].__closure__[0]
<cell at 0x7f675ab2dc90: int object at 0x9451e0>

但是它指的是变量，而不是定义函数时包含的实际对象。这将需要对功能框架进行更复杂的处理。

这意味着以下迭代会更改此单元格中包含的值，最后只有最后一次迭代是有意义的：

>>> lambdas[0].__closure__[0].cell_contents
4

如果要引用以前的值，可以使用参数的默认值：

>>> lambdas = [(lambda i=i: i) for i in range(5)]
>>> for lamb in lambdas:
...     print(lamb())
... 
0
1
2
3
4

关于第二个版本。property被实现为描述符（另请参见此答案），因此必须在类中设置它才能正常工作。其他装饰器也是如此，例如staticmethod和classmethod。property正如您所观察到的，将它们放在一个实例中只会返回该对象。

该行：

setattr(notebook,'_notes',{note.name : note.size for note in notes})

可以安全地更改为更简单、更易读的：

notebook._notes = {note.name : note.size for note in notes}
于 2014-03-11T13:01:32.993 回答
1

不过，还有一些食物。要在第一组代码中简单地获得您想要做的事情，您可以在没有所有额外技巧的情况下做到这一点。

最简单的方法是直接将属性设置为所需的属性。（代码合并在不适当的庄园中只是为了节省空间）

class Note:
    def __init__(self, name, value): self.name, self._size = name, value
    size = property(lambda x: x._size+1)

class Notebook(object):
    def __new__(cls, *notes):
        notebook = object.__new__(cls)
        notebook._notes = {note.name: note.size for note in notes}
        for note in notes: setattr(notebook, note.name, note.size)
        return notebook


memo1, report1 = Note("memo", 5), Note("report", 20)
notebook1 = Notebook(memo1, report1)

print(notebook1.memo, notebook1.report) # 6 21

memo2, report2 = Note("memo", 35), Note("report", 40)
notebook2 = Notebook(memo2,report2)

print(notebook2.memo, notebook2.report) # 36 41
print(notebook1.memo, notebook1.report) # 6 21
notebook1.memo += 5
print(notebook1.memo) # 11
print(memo1.size) # 6
memo1.size += 5 # AttributeError: can't set attribute

第二种方法是让笔记本真正成为您传递给它的所有笔记的容器。这样，它只会更新原始类对象，并且基本上只是它们的持有者。

class Note2(object):
    def __init__(self, name, value): self.name, self._size = name, value
    def _set_size(self, value): self._size = value
    size = property(lambda x: x._size+1, _set_size)
    def __repr__(self): return str(self.size) #simple trick to gain visual access to .size

class Notebook2(object):
    def __new__(cls, *notes):
        notebook = object.__new__(cls)
        notebook._notes = {note.name: note.size for note in notes}
        for note in notes: setattr(notebook, note.name, note)
        return notebook

memo1, report1 = Note2("memo", 5), Note2("report", 20)
notebook1 = Notebook2(memo1, report1)
print(notebook1.memo, notebook1.report) # 6 21
memo2, report2 = Note2("memo", 35), Note2("report", 40)
notebook2 = Notebook2(memo2, report2)
print( notebook2.memo, notebook2.report) # 36 41
print(notebook1.memo, notebook1.report) # 6 21
notebook1.memo.size += 16
print(notebook1.memo) # 23
print(memo1) # 23, Notice this will also set the original objects value to the new value as well
notebook1.memo += 15 # TypeError: unsupported operand type(s) for +=: 'Note2' and 'int' - It is true without making it as a property does make it less effective to work with

也应该可以按照您提供的链接中的建议使每个 Note 类成为具有前导下划线的 Notebook 成员（即 notebook._memo），然后为 Notebook 创建一个属性，将 Note 名称链接到大小（即 notebook. memo 将是 notebook._memo.size 的链接）。希望这些例子有所帮助。

原始答案。

有趣的想法，简单地让它在这里工作是你原始版本的破解：

class Note(object):
    def __init__(self,name, size):
        self.name = name
        self._size = size

    def _get_size(self, notebook_class=None):
        return self._size

    def _set_size(self, notebook_class=None, size=0):
        self._size = size

class Notebook(object):
    def __new__(cls,*notes):
        notebook = object.__new__(cls)
        for note in notes:
            setattr(notebook.__class__, note.name, property(note._get_size, note._set_size))
        return notebook

但是，无论如何，当您将每个 Note 类摄取到 Notebook 时，您似乎都在删除它们，这样您就可以做一些更容易的事情： 

class Note(object):
    def __init__(self, name, size):
        self.name = name
        self.size = size

class Notebook(object):
    def __new__(cls, *notes):
        notebook = object.__new__(cls)
        for note in notes:
            setattr(notebook.__class__, note.name, note.size)
        return notebook

为了更有帮助，我真的需要知道目标或您想要采取的总体思路。以这种奇怪的方式设置属性似乎令人困惑，但只在创建类时执行一次，而不是能够动态添加和删除它们的示例。

希望这有帮助

于 2014-03-11T13:30:21.303 回答