了解Python类实例化

Question

Trying to figure out class inheritance of class attributes that are themselves classes. Here's what I'm trying to do:

class foo:
    hello = None
    world = None

    def __init__(self, **kwargs):
        for k,v in kwargs.items():
            if hasattr(self, k):
                setattr(self, k, v)
            else:
                raise AttributeError(f'class foo has no attribute {k}')


class foo2:
    hi = None
    earth = None

    def __init__(self, **kwargs):
        for k,v in kwargs.items():
            if hasattr(self, k):
                setattr(self, k, v)
            else:
                raise AttributeError(f'class foo has no attribute {k}')

class bar:
    foo_attr = foo(hello=1, world=2)
    foo2_attr = foo2(hi=3, earth=4)


class bar2(bar):
    def __init__(self):
    super().__init__()

So I have 2 base classes ( foo and foo2 ) with 2 attributes each ( hello & world , hi & earth , respectively).

I have another base class ( bar ) that has class attributes inside with default values for foo and foo2 .

Update (to include question):

Lastly, I have bar2 which is a subclass of bar . How can I change the values of an attribute of a subclass that are themselves, classes? (say hello attribute of the foo_attr in bar2)

I'm trying to set a default value for bar but i want to be able to set different attributes for each of the class attributes inside bar when I subclass it. This way, I can create a bunch of subclasses of bar like so:

a bar2 with default attributes except foo2.earth which i set to 20. So that means bar2 has:

• foo.hello = 1
• foo.world = 2
• foo2.hi = 3
• foo2.earth = 20

and then still be able to create a bar3, with say default attributes for foo() and foo2() except for foo.hello, which maybe I want to set to 30 and then add a new attribute of say "jeez".

How do I go about doing this?

Answer 1

It looks like you want to create an explicit constructor for bar and bar2 so that you can choose the attributes:

class bar:
    def __init__(self, hello=1, world=2, hi=3, earth=4)
        self.foo_attr = foo(hello=hello, world=world)
        self.foo2_attr = foo2(hi=hi, earth=earth)

class bar2:
    def __init__(self)
        bar.__init__(self, earth=20)

You can still add new attributes in the new classes.

Answer 2

I think you need to put the functionality into foo and foo2 and you have less duplication if those inherit from a common super class with the functionality. The below script works (I had to remove the 'f' strings because I'm mired in the dark old days of python 3.5). There is still some work implementing the bar subclasses, but relatively sane.

import copy

class Fooinator:

    def __init__(self, **kwargs):
        badniks = self._update_instance(**kwargs)
        if badniks:
            raise AttributeError('class foo has no attributes {}'.format(badniks))

    def _update_instance(self, **kwargs):
        """Update self for variables defined at the class level returning
        names of variables not used by this class. """
        badniks = []
        for k,v in kwargs.items():
            if hasattr(self, k):
                setattr(self, k, v)
            else:
                badniks.append(k)
        return badniks

    def opt_clone(self, **kwargs):
        """Given keyword arguments, clone a copy of self if any of them are
        used by this class, else return self."""
        for k in kwargs:
            if hasattr(self, k):
                me_2 = copy.copy(self)
                me_2._update_instance(**kwargs)
                return me_2
        return self


class foo(Fooinator):
    hello = None
    world = None


class foo2(Fooinator):
    hi = None
    earth = None


class bar:
    foo_attr = foo(hello=1, world=2)
    foo2_attr = foo2(hi=3, earth=4)


class bar2(bar):
    foo2_attr = bar.foo2_attr.opt_clone(earth=20)

b = bar2()
print(b.foo_attr.hello, b.foo_attr.world, b.foo2_attr.hi, b.foo2_attr.earth)