class Some_Class(object):
    def __init__(self):
        self._somevalue = 0 
    def get_value(self):
        print ("calling get method to return value")
        return self._somevalue 
    def set_value(self, value):
        print ("calling set method to set value")
        self._somevalue = value 
    def del_attr(self):
        print ("calling delete method to delete value")
        del self._somevalue
    x = property(get_value, set_value, del_attr,"I'm the 'x' property.")

# obj.x

class Some_Class(object):
    _x =None
    def __init__(self):
        self._x = name
    @property
    def x(self):
        print("calling get method to return value")
    @x.setter
    def x(self,value):
        print("calling set method to set value")
        self._x=value
    @x.deleter
    def x(self):
        print("calling delete method to delete value")
        del self._x

#!/usr/bin/python 
# _*_coding: utf-8 _*_
class Date(object):
    def __init__(self,year,month,day): 
        seif.year = year 
        self.month = month 
        self.day = day
    def get_date(self):
        return self.year+"-"+self.month+"-"+self.day
    def set_date(self,date_as_string):
        year,month,day = date_as_string.split ('-')
        if not (2000 <= year <=2015 and 0 <= month <= 12 and 0 <=day <= 31):
            print ("year should be in [2000:2015]") 
            print ("month should be in [0:12]") 
            print ("day should be in [0,31]")
            raise AssertionError
        self.year = year 
        self.month = month 
        self.day = day
    date =property(get_date ,set_date)

class PropertyTest(object):
    def __init__(self):
        self.__var1=20
    @property
    def x(self):
        return self.__var1

def update_meta (self,other):
    self.__name__= other.__name__
    self.__doc__ = other.__doc__
    self.__dict__.update(other.__dict__)
    return self

class UserProperty (property):
    def __new__(cls, fget=None, fset=None, fdel=None, doc=None):
        if fget is not None:
            def __get__(obj,objtype=None, name=fget.__name__):
                fget = getattr(obj , name)
                print ("fget name:"+fget.__name__ )
                return fget()
            fget = update_meta(__get__, fget)
        if fset is not None:
            def __set__(obj ,value, name=fset.__name__ ):
                fset = getattr(obj,name)
                print ("fset name:"+fset.__name__)
                print ("setting value:" +str(value))
                return fset(value)
            fset = update_meta(__set__,fset)
        if fdel is not None:
            def __delete__(obj,name=fdel.__name__):
                fdel = getattr(obj, name)
                print ("warning: you are deleting attribute using fdel.__name__")
                return fdel()
            fdel = update_meta(__delete__, fdel)
        return property(fget, fset, fdel, doc)

class C(object):
    def get(self):
        print ('calling C.getx to get value')
        return self._x
    def set(self, x):
        print ('calling C.setx to set value')
        self._x = x
    def delete(self):
        print ('calling C.delx to delete value')
        del self._x
    x = UserProperty(get,set,delete)

def ro_property(obj , name, value):
    setattr (obj.__class__,name, property (lambda obj : obj.__dict__["__"+name]))
    setattr (obj, "__" + name, value)

class ROClass(object):
    def __init__(self, name, available):
        ro_property (self, "name",name)
        self.available = available