How does polymorphism work in Python?

I'm new to Python... and coming from a mostly Java background, if that accounts for anything.

I'm trying to understand polymorphism in Python. Maybe the problem is that I'm expecting the concepts I already know to project into Python. But I put together the following test code:

class animal(object):
    "empty animal class"

class dog(animal):
    "empty dog class"

myDog = dog()
print myDog.__class__ is animal
print myDog.__class__ is dog

From the polymorphism I'm used to (e.g. java's instanceof), I would expect both of these statements to print true, as an instance of dog is an animal and also is a dog. But my output is:

False
True

What am I missing?

The is operator in Python checks that the two arguments refer to the same object in memory; it is not like the is operator in C#.

From the docs:

> The operators is and is not test for object identity: x is y is true if and only if x and y are the same object. x is not y yields the inverse truth value.

What you're looking for in this case is isinstance.

> Return true if the object argument is an instance of the classinfo argument, or of a (direct or indirect) subclass thereof.

>>> class animal(object): pass

>>> class dog(animal): pass

>>> myDog = dog()
>>> isinstance(myDog, dog)
True
>>> isinstance(myDog, animal)
True

However, idiomatic Python dictates that you (almost) never do type-checking, but instead rely on duck-typing for polymorphic behavior. There's nothing wrong with using isinstance to understand inheritance, but it should generally be avoided in "production" code.

phimuemue and Mark have answered your question. But this is ALSO an example of polymorphism in Python, but it's not as explicit as your inheritance based example.

class wolf(object): 
    def bark(self):
        print "hooooowll"

class dog(object): 
    def bark(self):
        print "woof"


def barkforme(dogtype):
    dogtype.bark()


my_dog = dog()
my_wolf = wolf()
barkforme(my_dog)
barkforme(my_wolf)

Try isinstance(myDog, dog) resp. isinstance(myDog, animal).

just nice example how it is possible to use same field of 2 totally different classes. It is more close to template.

class A:
    def __init__(self, arg = "3"):
        self.f = arg
a = A()
a.f # prints 3
class B:
    def __init__(self, arg = "5"):
        self.f = arg
b = B()
b.f # prints 5


def modify_if_different(s,t, field):
    if s.__dict__[field] != t.__dict__[field]:
        t.__dict__[field]  = s.__dict__[field]
    else:
        s.__dict__[field]  = None

modify_if_different(a,b,"f")
b.f # prints 3
a.f # prints 3