What about an attribute-level decorator-like syntax, like:
@instattr x = 42
@instattr @lazy y = 
@instattr: x = 42
@instattr: @lazy: y = 
This would have the benefit of a keyword-like syntax without actually needing a new keyword.
The question is how such a system would work in a general manner. Of course these aren't decorators, something new would be needed. I see two main approaches.
1. These functions are called both at class creation and initialization time with arguments that let it decide what to do. So perhaps it is given whatever is on the right side of the "=", the class, and the class instance (which is None at class creation time). Perhaps it is given the variable name as a string, or perhaps Python magically adds the name to the namespace whenever the function returns. Alternatively, this could be a class and there are two dunder methods that are called at class creation time and class initialization time.
2. These are called at attribute access time. Python sets up the attribute as a special property, and whenever the attribute is accessed the function is given arguments that allow it to infer what is going on. It then controls if and how the variable is accessed. Alternatively, this could be a class and there are dunder methods called at various times.
The second approach would be more flexible, while the first approach would require less work for developers for basic tasks. The two approaches are not mutually-exclusive, either, especially if a dunder method-based approach is used.
I know that strictly speaking the property-based approach could be implemented in the function-based approach, but that would be a lot more work.