Python-继承已初始化的类而不调用超级构造函数

我正在尝试创建一个Python地名录模块。我有以下课程：州、县和市。我需要一个州去了解它所有的县，一个县去了解它所有的城市，一个城市去了解它的县和州。（Python 3.x）

以下是我所拥有的：

class State(object):
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)

    def state_name(self):
        return self.state


class County(State):
    def __init__(self, state_class, **kwargs):
        self.__bases__ = (state_class, )
        self.__dict__.update(kwargs)


class City(County):
    def __init__(self, county_class, **kwargs):
        self.__bases__ = (county_class, )
        self.__dict__.update(kwargs)

class A:
    def __init__(self, name):
        self.name = name

    def getA(self):
        return self.name

class B(A):
    def __init__(self, aname, bname):
        self.name = bname
        super().__init__(aname)

b = B('AAA', 'BBB')
print(b.getA())
# AAA

那么我会：

fl = State(state='Florida', abb='FL', fips='12')
mdc = County(fl, county='Miami-Dade', fips='086')
setattr(fl, 'miami_dade', mdc)
rmd = City(mdc, city='Richmond', fips='60230')
setattr(mdc, 'richmond', rmd)


print(fl.state, fl.abb, fl.fips, fl.miami_dade.county, fl.miami_dade.richmond.city)
# Florida FL 12 Miami-Dade Richmond
print(fl.state_name())
# Florida
print(fl.__dict__)
# {'abb': 'FL', 'miami_dade': <__main__.County object at 0x0000000002C44A20>, 'fips': '12', 'state': 'Florida'}
print(fl.miami_dade.__dict__)
# {'__bases__': (<__main__.State object at 0x000000000358A048>,), 'fips': '086', 'county': 'Miami-Dade', 'richmond': <__main__.City object at 0x0000000002C44A90>}
print(fl.miami_dade.richmond.__dict__)
# {'fips': '60230', 'city': 'Richmond', '__bases__': (<__main__.County object at 0x0000000002C44A20>,)}
print(isinstance(fl.miami_dade.richmond, State))
# True

我希望我的City类在State和County类中使用方法。我最好的猜测是，code

print（fl.miami\u dade.richmond.state\u name（））

正在执行

state\u name（）

方法，使用City实例中的属性，而不是state实例中的属性

我不明白我做错了什么County类是否可以继承已初始化状态类的方法和属性？

---

更多信息：
我不想在城市和县做

super（）。\uuuu init\uuuu（）

，例如

a=City（'settle'，'King'，'Washington'）

，因为以下原因。
我有56个州（包括美国领土）、3234个县和16352个城市的数据。如果我让每个城市都有一份其县和州的副本，那就是浪费记忆。此外，我还有一个坐标，它为每个县（约20MB）形成一个多边形，平均每个县有约50个城市；如果每个城市都有一份副本，那就超过了一场演出。

---

好吧，这不是一个好的结构，我正在做什么，我正在改变它，但我不喜欢它，当我不明白的东西。我想知道这里发生了什么
这里有一个简化版本：

class State(object):
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)

    def state_name(self):
        return self.state


class County(State):
    def __init__(self, state_class, **kwargs):
        self.__bases__ = (state_class, )
        self.__dict__.update(kwargs)


class City(County):
    def __init__(self, county_class, **kwargs):
        self.__bases__ = (county_class, )
        self.__dict__.update(kwargs)

class A:
    def __init__(self, name):
        self.name = name

    def getA(self):
        return self.name

class B(A):
    def __init__(self, aname, bname):
        self.name = bname
        super().__init__(aname)

b = B('AAA', 'BBB')
print(b.getA())
# AAA

好的，我明白了。 但在这里：

class A2:
    def __init__(self, name):
        self.name = name

    def getA2(self):
        return self.name

class B2(A2):
    def __init__(self, A2Obj, name):
        self.__bases__ = (A2Obj, )
        self.name = name

a2 = A2('AAA2')
b2 = B2(a2, 'BBB2')
print(b2.getA2())
# BBB2
print(a2.name)
# AAA2

---

a2

知道它的名字是AAA2。为什么

b2.getA2（）

给我BBB2？就像

b2

继承了

a2

的方法，但没有继承属性。我怎样才能使b2像上面的例子那样工作？

你可能使用了错误的结构：你的城市不是一个县，你的县不是一个州。 你应该使用复合词而不是派生词

class State(object):
  def __init__(self, **kwargs):
    self.__dict__.update(kwargs)

  def state_name(self):
    return self.state


class County(object):
  def __init__(self, state, **kwargs):
    self.state=state # this will just reference the state object
    self.__dict__.update(kwargs)
  def getStateName(self):
    return self.state.state


class City(object):
  def __init__(self, county, **kwargs):
    self.county = county
    self.__dict__.update(kwargs)
  def getStateName(self):
    return self.county.getStateName()

---

如果您希望以后能够在不跟踪对象的情况下检索它们，可以使用静态字典并在init期间添加创建的对象（例如“FL”->State（“Florida”））。然后添加一个静态方法来检索正确的对象。

听起来您需要一个包含一些表的数据库，这些表描述了州->县和县->市的关系（因此，州->市，市->县和市->州的关系可以根据需要反转或合并）。在内存中，如果您想在索引数值计算方面做得更好，通常可以使用一些哈希表（

dict

在Python中）或一组

pandas.DataFrame

对象来完成。但实际上，您可能只想将数据放入一组简单的postgres表中，然后使用sqlalchemy（如果您真的想要表示实体的类）。请记住，没有什么强迫您以面向对象的方式在这些数据的基础上构造计算。您可以自由地使用一些包含数据的

dict

s，然后编写助手函数，根据需要提取、合并、连接和处理这些

dict

s的内容。它可以像从州（州、市、一些其他参数）获取城市一样，在功能级别上进行组合，而不是在类组合上。很多数字代码这样做更好。@F先生-你说得对，有更好的方法。我这么做是出于好奇，但现在我不明白发生了什么，这让我很困扰。我编辑了我的问题，加入了一个更简单的例子。这很有趣-我做了和你在那里做的一样的事情，但我把县变成了州的内部阶级，把市变成了县的内部阶级（我尝试了一些结构）。我用一个简单的例子更新了我的问题，说明了我想理解的内容。