Python is entirely object oriented and using classes is made relatively simple. Beginners have a certain angst when it comes to using classes. There is a hump in the learning curve, which I like to overcome with this example. Inheritance really makes sense and saves you a lot of extra code writing. The best way to learn about classes and object oriented programming is to write more and more of your code with class!

Comments
Multiple inheritance python
# a simple example of a class inheritance
# tested with Python24     vegaseat    10aug2005

help('object')  # test

class Class1(object):
    """
    Class1 inherits the most basic container class object (just a place holder)
    this is the newer class writing convention, adding (object) is "still" optional
    """
    
    k = 7
    
    def __init__(self, color='green'):
        """
        Special method __init__() is called first (acts as Constructor).
        It brings in data from outside the class like the variable color.
        (in this case color is also set to a default value of green)
        The first parameter of any method/function in the class is always self,
        the name self is used by convention.  Assigning color to self.color allows it
        to be passed to all methods within the class.  Think of self as a carrier,
        or if you want impress folks call it target instance object.
        The variable k is assigned a value in the class, but outside of the methods.
        You can access k in a method using self.k
        """
        self.color = color
    
    def Hello1(self):
        print "Hello from Class1!"
        
    def printColor(self):
        """in this case self allows color to be passed"""
        print "I like the color", self.color
     
    def __localHello(self):
        """
        A variable or function with a double underline prefix and no or max. single
        underline postfix is considered private to the class and is not inherited or
        accessible outside the class.
        """
        print "A hardy Hello only used within the class!"


class Class2(Class1):
    """
    Class2 inherits Class1 (Class2 is the subclass, Class1 the base or superclass)
    Class1 has to be coded before Class2 for this to work!!!
    Class2 can now use any method of Class1, and even the variable k
    """

    def Hello2(self):
        print "Hello from Class2!"
        print self.k, "is my favorite number"
        
    
# the color blue is passed to __init__()
c1 = Class1('blue')

# Class2 inherited method __init__() from Class1
# if you used c2 = Class2(), the default color green would be picked
c2 = Class2('red')

print '-'*20
print "Class1 says hello:"
c1.Hello1()

print '-'*20
print "Class2 says a Class1 hello:"
c2.Hello1()

print '-'*20
print "Class2 says its own hello:"
c2.Hello2()

print '-'*20
print "Class1 color via __init__():"
c1.printColor()

print '-'*20
print "Class2 color via inherited __init__() and printColor():"
c2.printColor()

print '-'*20
print "Class1 changes its mind about the color:"
c1 = Class1('yellow')  # same as:  c1.__init__('yellow')
c1.printColor()

print '-'*20
print "Wonder what Class2 has to say now:"
c2.printColor()

print '-'*20
# this would give an error!  Class1 does not have a method Hello2()
if hasattr(Class1, "Hello2"):
    print c1.Hello2()
else:
    print "Class1 does not contain method Hello2()"

# check inheritance
if issubclass(Class2, Class1):
    print "Class2 is a subclass of Class1, or Class2 has inherited Class1"

# you can access variable k contained in Class1
print "Variable k from Class1 =", c1.k

print '-'*20
# this would give an error!  You cannot access a class private method
if hasattr(Class1, "__localHello()"):
    print c1.__localHello()
else:
    print "No access to Class1 private method __localHello()"

Python has a leg up over Java. Python can have multiple inheritance, just separate the inherited classes with a comma.

Starting with Python3
class Class1(object):
can be written
class Class1:
object is now automatically inherited.

Just a few more rumblings:

''' class_private1.py
class variable or method names with a two underline prefix
will be private too the class
'''

class A(object):
    # actually creates self.k which is public
    k = 1234
    # variable names like
    # __m or __m_ will be private to the class
    # same goes for names of class methods
    __m = 5678
    # _n or _n_ or _n__ or __n__ will be public
    __n__ = 999
    # __init__() will be used first, if it's there
    def __init__(self, v):
        self.value = v

    def add(self, x):
        return self.value + x

    def __subtract(self, y):
        """function only internal/private to class"""
        return self.value - y

    def deduct(self, y):
        return self.__subtract(y)

class B(A):
    '''inherit class A, but not private methods or variables'''
    def __init__(self, *arg):
        #super(B, self).__init__(*arg)
        A.__init__(self, *arg)


a = A(7)    # implies A.__init__(a, 7)
print(A)    # <class '__main__.A'>
print(a)    # <__main__.A object at 0x02854A70>

print(a.add(2))     # 9
print(a.deduct(4))  # 3
print(a.value)      # 7
print(a.k)          # 1234

print(a.__n__)      # 999

# note that __m is private to the class
# so this will give an error
#print(a.__m)        # AttributeError: 'C' object has no attribute '__m'

# this would also create a similar error
#print(a.__subtract(4))

b = B(2)
print(b)  # <__main__.B object at 0x02794B10>

# works as expected, method add has been inherited
print(b.add(5))  # 7

# does not work as expected, method __subtract has not been inherited
print(b.deduct(1))  # 1
The article starter has earned a lot of community kudos, and such articles offer a bounty for quality replies.