Question

我正在构建一个粒子过滤器来处理来自pandas DataFrame的数据。过滤器背后的想法是迭代以估计最佳结果（类似于蒙特卡罗）。我有一个基类ExperimentalData()，它有基本的方法来收集数据等。我将构建另一个类来拥有不同的过滤器。过滤器的类始终从ExperimentalData()派生。

在我的class ParFilter(ExperimentalData)内，我使用方法def particleFilter(self, N=1000)来运行过滤器并获得所需的估算值。因为我需要在迭代期间访问数据，所以在内部构建class Iterator(object)我将继续处理数据。

将数据传递到类Iterator()时遇到问题。我尝试了大多数情况，我认为应该有效，但有AttributeError: 'Iterator' object has no attribute 'myData'。最终我能够传递一些数据，但它与我预期的数据对象不同。

我的代码简化为示例：

import numpy as np
import pandas as pd

class ExperimentalData(object):
    def __init__(self):
        self.xTrueSource = 100
        self.yTrueSource = -7
        print 'source %s  %s' % (self.xTrueSource,self.yTrueSource)
        xSampPoints = np.arange(0,200)
        yTrueSignal = 100/(np.sqrt((self.xTrueSource - xSampPoints)**2 + (self.yTrueSource)**2))
        ySampPoints = yTrueSignal+np.random.randn(200)
        self.myData = pd.DataFrame({'x':xSampPoints,'ySamp':ySampPoints,'yTrue':yTrueSignal})
        #print self.myData
    def __str__(self, rows=2):           
        dfPrintStart = (self.myData[:rows]).to_string()
        dfPrintEnd =(self.myData[-rows:]).to_string()
        stringToPrint='\nPRINTNG INITIAL DATAFRAME FIRST %d ROWS and LAST %d ROWS \n %s\n...\n%s\n'\
                        % (rows, rows, dfPrintStart, dfPrintEnd)
        return stringToPrint

class ParFilter(ExperimentalData):

    def particleFilter(self, N=1000):
        '''function runs particle filter'''
        class Iterator(object):
            def __init__(self):
                '''initialise all values for iteration'''
                self.iteration = 0
                frameToWork = ParFilter().myData                
                print 'FROM CLASS Iterator.__init__ \n%s' % frameToWork
            def iterate(self):
                '''performing one step at the time'''
                self.iteration += 1
                print self.iteration
        myPartFilter = Iterator()
        for n in range(N):
            myPartFilter.iterate()
        return myPartFilter

if __name__ == '__main__':
    data = ParFilter()
    print data
    data.particleFilter(10)

问题在于，当我初始化我的类时，我使用具有特定值的dataFrame，但是当我执行步骤：frameToWork = ParFilter().myData而不是采用相同的数据对象时，我生成具有不同数据的新对象。输出快照：

PRINTNG INITIAL DATAFRAME FIRST 2 ROWS and LAST 2 ROWS 
   x     ySamp     yTrue
0  0  0.510414  0.997559
1  1  1.522934  1.007585
...
       x     ySamp     yTrue
198  198  1.508216  1.017815
199  199  2.409181  1.007585

FROM CLASS Iterator.__init__ 
   x     ySamp     yTrue
0  0  0.727060  0.997559
1  1  0.631976  1.007585

初始化中ySamp的第一个值是0.510414，它应该在Iterator而不是0.727060中相同。所以我创建了新对象。

我无法弄清楚如何将原始myData对象放入Iterator我尝试：

    class Iterator(ParFilter):
        def __init__(self):
            '''initialise all values for iteration'''
            self.iteration = 0
            frameToWork = self.myData

AttributeError: 'Iterator' object has no attribute 'myData'。

我尝试class Iterator(self.ParFilter)与AttributeError: 'ParFilter' object has no attribute 'ParFilter'以及更多但没有结果。

（我必须使用pandas DataFrame，因为我的基类非常大，并且得到的大数据框架不像示例）

Answer 1

您的代码的问题是内部类正在尝试访问外部类的成员变量。这是不可能的，因为他们都使用self来引用他们当前的实例，而内部类的self参数会影响外部类的self。您需要为其中一个使用不同的名称。

虽然你可以在其中一个方法中为第一个参数名实际使用不同的名称，但我建议在定义嵌套类之前简单地将其他名称绑定到外部self对象：

class Outer(object):
    def __init__(self):
        self.foo = "foo"

    def do_stuff(self):
        outer_self = self # give an extra name to `self` that won't be shadowed

        class Inner(object):
            def __init__(self):
                 self.bar = "bar"

            def do_inner_stuff(self):
                print(outer_self.foo, self.bar) # access the outer class's data

        i = Inner()
        i.do_inner_stuff()

这样可行，但它仍然可能不是最好的设计。嵌套类是不可序列化的，可能非常讨厌调试，如果可能的话应该避免使用。

更好的想法是取消您的类，只需将您需要的数据从外部类传递到内部类的构造函数，其中引用可以保存为成员变量：

class Outer(object):
    def __init__(self):
        self.foo = "foo"

    def do_stuff(self):
        i = Inner(self.foo) # pass relevant data to constructor
        i.do_inner_stuff()

class Inner(object):
    def __init__(self, foo):
        self.foo = foo # keep a reference to passed data
        self.bar = "bar"

    def do_inner_stuff(self):
        print(self.foo, self.bar)  # use the data

在嵌套类中使用对象继承的对象来运行迭代

1 个答案: