Question: For example:

```
name | startyear | endyear 
jon    2003       2005
jake   1999       2002
blake  1997       1998
jake   1995       1996
jason  1993       1994

```

Is there a way to return blake?

I want to know who was treasurer between the two terms of jake.

Answer: 
Don't declare the same name as a slot and as an instance method. Use different names, and access the slot as an attribute, not via `__dict__`.

```
class MyDescriptor(object):
    __slots__ = ['name']
    def __init__(self, name_):
        self.name = name_
    def __get__(self, instance, owner):
        return getattr(instance, self.name)
    def __set__(self, instance, value):
        setattr(instance, self.name, value)

class C(object):
    __slots__ = ['_a']
    a = MyDescriptor('_a')
    def __init__(self, val):
        self.a = val

foo = C(1)
print foo.a
foo.a = 2
print foo.a

```
Though of dubious value, the following trick will work, if it is ok to put the first `__slots__` in a subclass.

```
class A( object ):
    __slots__ = ( 'a', )

class B( A ):
    __slots__ = ()

    @property
    def a( self ):
        try:
            return A.a.__get__( self )
        except AttributeError:
            return 'no a set'

    @a.setter
    def a( self, val ):
        A.a.__set__( self, val )

```

(You can use your own descriptor rather than property.) With these definitions:

```
>>> b = B()
>>> b.a
'no a set'
>>> b.a = 'foo'
>>> b.a
'foo'

```

As far as I understand, `__slots__` is implemented with its own descriptor, so another descriptor after `__slots__` in the same class would just overwrite. If you want to elaborate this technique, you could search for a candidate descriptor in `self.__class__.__mro__` (or starting with `instance` in your own `__get__`).

**Postscript**

Ok ... well if you really want to use one class, you can use the following adaptation:

```
class C( object ):
    __slots__ = ( 'c', )

class MyDescriptor( object ):

    def __init__( self, slots_descriptor ):
        self.slots_descriptor = slots_descriptor

    def __get__( self, inst, owner = None ):
        try:
            return self.slots_descriptor.__get__( inst, owner )
        except AttributeError:
            return 'no c'

    def __set__( self, inst, val ):
        self.slots_descriptor.__set__( inst, val )

C.c = MyDescriptor( C.c )

```

If you insist on inscrutability, you can make the assignment in a metaclass or a class decorator.