Text-based Mario and Luigi objects
This is clearly Python2. To have better inheritance in Python2 you have to inherit from object.
Inheriting from object is classed as a new-style class, and is better than old ones.

class Parent(object):
    pass

class Child1(Parent): # No need to inherit object again.
    pass

You don't use __init__...
In your example code it may be bad to use it, since you are adding spells anyway.
And you're overwriting self.name in your class anyway, so it's quite pointless.

But lets say you wanted to have a default name for Child1,
and you could assign it to something else,
so you don't have to supply the name on every function.
You can do almost exactly the same as you are doing on every function.

def Parent(object):
    def __init__(self, name="Player", lives=3):
        self.name = name
        self.lives = lives

    def run(self):
        print "%s is running." % self.name

As for your print statements you should use str.format rather than the old 'sprintf'-like %.
There are quirks with % and str.format is a lot stronger.

print "{} is running.".format(self.name)


The above is exactly the same as your above prints, but I'm sure at one point you will want to print the name and the lives.
You can change the contents of the {}'s to allow you to use the name instead.
Which allows for greater readability, as now we know '[player name] is running'.

print "{0.name} is running.".format(self)


Why stop there you can show lives to!

print "{0.name} has {0.lives} live(s).".format(self)

As just saying 'use new style classes they are better than old style ones' isn't a compelling reason.
There is something that you can do with new-style classes, which is calling it's parents functions.
For example if we wanted to have the default name for Child1 as Luigi, you can do the following:

class Child1(Parent):
    def __init__(name="Luigi", **args):
        super(Child1, self).__init__(name=name, **args)


It's one good thing about new style classes, which get's improved in Python3 to:

class Child1(Parent):
    def __init__(name="Luigi", **args):
        super().__init__(name=name, **args)



This will now change the 'calling object' code to:

player1 = Child1('Jay')
player2 = Child1('Joe')

player1.run()
player1.jump()
player1.grow()
player2.run()




Here is Parent and Child1 with the above changes, note I removed all the self.name = name's.

class Parent(object):
    def __init__(name="Player", lives=3):
        self.name = name
        self.lives = lives

    def run(self):
        print "{0.name} is running.".format(self)

    def jump(self):
        print "{0.name} jumps over enemy. TOINK TOINK".format(self)

    def grow(self):
        print "{0.name} sarting to Grow".format(self)

class Child1(Parent):
    def __init__(name="Luigi", **args):
        super(Child1, self).__init__(name=name, **args)

    def blazing_fire(self):
        print "{0.name} used his blazingFire".format(self)