Question

As an example, just a couple of dummy objects that will be used together. FWIW this is using Python 2.7.2.

class Student(object):
    def __init__(self, tool):
        self.tool = tool

    def draw(self):
        if self.tool.broken != True:
            print "I used my tool. Sweet."
        else:
            print "My tool is broken. Wah."

class Tool(object):
    def __init__(self, name):
        self.name = name
        self.broken = False

    def break(self):
        print "The %s busted." % self.name
        self.broken = True

Hammer = Tool(hammer)
Billy = Student(Hammer)
Tommy = Student(Hammer)

That’s probably enough code, you see where I’m going with this. If I call Hammer.break(), I’m calling it on the same instance of the object; if Billy’s hammer is broken, so is Tommy’s (it’s really the same Hammer after all).

Now obviously if the program were limited to just Billy and Tommy as instances of Students, the fix would be obvious – instantiate more Hammers. But clearly I’m asking because it isn’t that simple, heh. I would like to know if it’s possible to create objects which show up as unique instances of themselves for every time they’re called into being.

EDIT: The kind of answers I’m getting lead me to believe that I have a gaping hole in my understanding of instantiation. If I have something like this:

class Foo(object):
    pass

class Moo(Foo):
    pass

class Guy(object):
    def __init__(self, thing):
        self.thing = thing

Bill = Guy(Moo())
Steve = Guy(Moo())

Each time I use Moo(), is that a separate instance, or do they both reference the same object? If they’re separate, then my whole question can be withdrawn, because it’ll ahve to make way for my mind getting blown.

Answer 1

After seeing the tenor of the answers here and remembering the Zen of Python, I’m going to answer my own dang question by saying, “I probably should have just thought harder about it.”

I will restate my own question as the answer. Suppose I have this tiny program:

class Item(object):
    def __init__(self):
        self.broken = False

    def smash(self):
        print "This object broke."
        self.broken = True

class Person(object):
    def __init__(self, holding):
        self.holding = holding

    def using(self):
        if self.holding.broken != True:
            print "Pass."
        else:
            print "Fail."

Foo = Person(Item())
Bar = Person(Item())

Foo.holding.smash()
Foo.using()
Bar.using()

The program will return “Fail” for Foo.using() and “Pass” for Bar.using(). Upon actually thinking about what I’m doing, “Foo.holding = Item()” and “Bar.holding = Item()” are clearly different instances. I even ran this dumpy program to prove it worked as I surmised it did, and no surprises to you pros, it does. So I withdraw my question on the basis that I wasn’t actually using my brain when I asked it. The funny thing is, with the program I’ve been working on, I was already doing it this way but assuming it was the wrong way to do it. So thanks for humoring me.