命名空间在继承中的顺序是什么？

Question

派生的 class 可以隐式访问其基础 class 成员函数，除非我弄错了。派生的 class 也可以通过像这样在调用前加上前缀来访问其基础 class' 属性：BaseClass.base_attribute。但我似乎不明白派生 class 的实例如何使用基 class 的方法。示例：

class Visitor():
    """ Interface to Visitor
    
    provide an interface to visitors that
    perform an operation on a data collection """
    
    def visitProduce():
        pass
    def visitMeat():
        pass
    def visitBakedGoods():
        pass
    def visitDairy():
        pass
    def visitNonFood():
        pass
        
        
        
class PriceVisitor(Visitor):
    __cost = 0.0        # total cost of groceries
    
    def __init__(self):
        self.__cost = 0.0
    def visitProduce(self, p):
        self.__cost += p.price()
    def visitMeat(self, m):
        self.__cost += m.price()
    def visitBakedGoods(self, b):
        self.__cost += b.price()
    def visitDairy(self, d):
        self.__cost += d.price()
    def visitNonFood(self, nf):
        self.__cost += nf.price()
        
        
class Groceries():
    shopping_cart = []      # list of grocery items
    
    def Groceries(self):
        self.shopping_cart = []     
    def addProduce(self, p):
        pass
    def addMeat(self, m, lb):
        pass
    def addBakedGoods(self, b):
        pass
    def addDairy(self, d):
        pass
    def addNonFood(self, nf):
        pass
    def accept(self, v):
        pass
    def getShoppingCart(self):
        print(self.shopping_cart)
    def calculateCost(self, v):
        for item in self.shopping_cart:
            item.accept(v)
            item.details()
            print('Total cost is: $', v.__cost)
            
            
            
class Produce(Groceries):
    def addProduce(self):
        Groceries.shopping_cart.append(self)
            
    def accept(self, v):
        v.visitProduce(self)
        
    def price(self):
        return self.__price
        
    def details(self):
        print(self.__name, ' for: $', self.__price + '')
        
        
        
class Apples(Produce):
    __name = None
    __price = 3.25
    
    def __init__(self, name):
        self.__name = name

这里是对 Apple、Produce、Groceries 和 PriceVisitor 的测试 classes

import VisitorPattern as vp

def main():
    # Visitor object
    my_visitor = vp.PriceVisitor()
    
    # Grocery object stores objects in its shopping_cart attribute
    my_groceries = vp.Groceries()
    
    # Add items
    red_apple = vp.Apples('red apple')
    gold_apple = vp.Apples('gold apple')
    red_apple.addProduce()
    gold_apple.addProduce()
    
    my_groceries.getShoppingCart()
    
    my_groceries.calculateCost(my_visitor)

if __name__ == '__main__':
    main()

现在，我的理解是，在构造 Apple 实例时，它可以访问 Produce 的方法 price()。使用 Apple class 的实例调用此方法将传递它自己的实例来代替 'self'。然后程序 returns __price 属性的值属于调用该方法的实例，在本例中为 Apple。但是，我收到此错误：

C:\Users\josep_000\Documents\School\Summer 2015\Python Assignment 4>python test.
py
[<VisitorPattern.Apples object at 0x026E0830>, <VisitorPattern.Apples object at
0x026E0910>]
Traceback (most recent call last):
  File "test.py", line 23, in <module>
    main()
  File "test.py", line 20, in main
    my_groceries.calculateCost(my_visitor)
  File "C:\Users\josep_000\Documents\School\Summer 2015\Python Assignment 4\Visi
torPattern.py", line 60, in calculateCost
    item.accept(v)
  File "C:\Users\josep_000\Documents\School\Summer 2015\Python Assignment 4\Visi
torPattern.py", line 71, in accept
    v.visitProduce(self)
  File "C:\Users\josep_000\Documents\School\Summer 2015\Python Assignment 4\Visi
torPattern.py", line 28, in visitProduce
    self.__cost += p.price()
  File "C:\Users\josep_000\Documents\School\Summer 2015\Python Assignment 4\Visi
torPattern.py", line 74, in price
    return self.__price
AttributeError: 'Apples' object has no attribute '_Produce__price'

绑定和命名空间在继承中实际是如何工作的？我可以只在 Produce 的每个派生 classes 中编写 price() 方法，但这会破坏继承点。我认为我的问题也源于名称修改，但仍然不知道如果我不创建我的属性会发生什么 'private'。澄清会很好。谢谢

编辑

我把 Groceries 的构造函数声明错了：

# Wrong way
def Groceries(self):   
    self.shopping_cart = []

# Should be
def __init__(self):
    self.__shopping_cart = []

全职工作和晚上作业的产物

Answer 1

What is the order of namespaces in inheritance?

Python 使用方法解析顺序查找绑定到该对象实例的方法。

它还会调用名称修改，这就是您找不到该方法的原因，_Produce__price。您正在尝试使用 .__price 但是当它被继承时，Python 将 class 的名称添加到名称的前面。不要使用两个下划线，将两个下划线更改为一个，您的代码将按预期工作，并且您将始终如一地查找 ._price，它不会调用名称修改。

有关此内容的更多信息，请参阅文档：

https://docs.python.org/2/tutorial/classes.html#private-variables-and-class-local-references

Answer 2

并不是对您所有问题的真正直接回答，但我希望以下代码能够阐明如何在 Python 中进行继承。

class Produce(object):

    def __init__(self, name=None, price=None):
        self.__name = name
        self.__price = price

    def __str__(self):
        return self.__name

    @property
    def bulk_price(self):
        return self.__price * 100

class Apple(Produce):

    def __init__(self, name="Apple"):
        self.__name = name
        self.__price = 3.25
        super(self.__class__, self).__init__(self.__name, self.__price)

a = Apple("Gold Apple")
print a
print a.bulk_price
# Gold Apple
# 325.0

如您所见，我使 name 和 price 在两个 class 中都无法访问。这样，我就不能直接明确地调用它们，即 a.__price。通过在子 class 中也使用 super，我可以避免进一步 class 引用基础 class，同时仍然可以访问其方法 .

Answer 3

我看到你的错误了，你的parent需要调用child的函数，但是你没有将child传给parent，所以它会得到errors.Now我举个例子：

class A:
    def __init__(self, handler):
        self.a = 5
        self.real_handler = handler

    def get(self):
        print "value a = %d"%self.a
        self.real_handler.put()

class B(A):
    def __init__(self):
        A.__init__(self, self)    ##transport B to A
        self.b = 3

    def get(self):
        print "value b is %d"%self.b
        A.get(self)

    def put(self):
        self.b = 6
        print "value b change into %d"%self.b

if __name__=="__main__":
    b = B()
    b.get()

在父B中，会调用子A的函数put()。希望对您有所帮助。

命名空间在继承中的顺序是什么？

What is the order of namespaces in inheritance?

python

inheritance

namespaces

name-mangling

编辑