Python: How determine if attribute (by name) is class or instance attribute?

Goal (in Python 2.7):

Inspecting an arbitrary object, find all of the instance variables. But exclude class variables.

Ultimate goal:

Print useful details of an object, from a third-party class library that doesn't provide a useful "str" implementation. (Maya's Python API, version 1, which is a simple SWIG wrapper. not using version 2, because I'm learning from some version 1 examples.)

Example class:

# ---------- class Vector ----------
class Vector(object):
    def __init__(self, x=0.0, y=0.0, z=0.0):
        self.x, self.y, self.z = x, y, z
    # Provide useful info for 'repr(self)', 'str(self)', and 'print self'.
    def __repr__(self):
        return 'Vector({0}, {1}, {2})'.format(self.x, self.y, self.z)
    # math operators
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y, self.z + other.z)
    # a simple method
    def ApproximateLength(self):
        return self.x + self.y + self.z
    # list/sequence/iterator support.
    def tolist(self):
        return [self.x, self.y, self.z]
    def __len__(self):
        return 3
        # No need for "next(self)", because we create a list, use its iterator.
    def __iter__(self):
        return iter(self.tolist())
# class variable
Vector.Zero = Vector()

Solution so far:

import inspect
import types
def printElements(ob):
    for x in ob: print x
# Excludes 'internal' names (start with '__').
def Public(name):
    return not name.startswith('__')
def Attributes(ob):
    # Exclude methods.
    attributes = inspect.getmembers(ob, lambda member: not inspect.ismethod(member))
    # Exclude 'internal' names.
    publicAttributes = filter(lambda desc: Public(desc[0]), attributes)
    return publicAttributes

Example usage:

vec = Vector(1.0, 2.0, 3.0)
printElements(Attributes(vec))   

Output:

('Zero', Vector(0.0, 0.0, 0.0))
('x', 1.0)
('y', 2.0)
('z', 3.0)

This class does print itself well:

print vec

=>

Vector(1.0, 2.0, 3.0)

The goal is to extract similar information, for classes that I don't have source to (or don't want to modify the source of). Those classes have many class variables, which bury the information I seek.

Question:

How detect that 'Zero' is a "class variable", inherited from Vector, to eliminate it from the output?

Clumsy approach I will use if no better way:

printElements(Attributes(type(vec)))

lists the attributes on the object's type. Could test each attribute of "vec" against the attributes of "type(vec)", excluding any that match. I don't care about the subtle possibility that the same named attribute exists on both class and instance. So this would satisfy my requirements.

However, that seems clumsy. Is there a more direct way to determine whether the attribute is inherited from the class?

EDIT: Incorporating Joran's answer:

def IsClassVar(self, attrName):
    return hasattr(self.__class__, attrName)
def Attributes(ob):
    ....
    publicAttributes = filter(lambda desc: Public(desc[0]), attributes)
    # Exclude 'class' variables.
    # NOTE: This does not attempt to detect whether the instance variable is different than the class variable.
    publicAttributes = filter(lambda desc: not isClassVar(ob, desc[0]), publicAttributes)
    return publicAttributes

This gives the desired result:

printElements(Attributes(vec))   

=>

('x', 1.0)
('y', 2.0)
('z', 3.0)

Alternative, To detect instance variable overriding class variable:

def IsClassVar(self, attrName):
    return hasattr(self.__class__, attrName)
# REQUIRE attrName already known to be supported by self.
# But just in case, return False if exception, so will be skipped.
def IsNotSameAsClassVar(self, attrName):
    try:
        if not IsClassVar(self, attrName):
            return True
        # If it has different value than class' attribute, it is on the instance.
        return getattr(self, attrName) is not getattr(self.__class__, attrName)
    except:
        return False
def Attributes(ob):
    ....
    publicAttributes = filter(lambda desc: Public(desc[0]), attributes)
    # Exclude 'class' variables.
    # More complete solution.
    publicAttributes = filter(lambda desc: IsNotSameAsClassVar(ob, desc[0]), publicAttributes)
    return publicAttributes

Now if we override 'Zero' on vec, it gets included:

# Probably a bad idea, but showing the principle.
vec.Zero = "Surprise!"

Then:

print vec.Zero
print Vector.Zero

=>

Surprise!
Vector(0.0, 0.0, 0.0)

And:

printElements(Attributes(vec))   

=>

('Zero', 'Surprise!')
('x', 1.0)
('y', 2.0)
('z', 3.0)