What you describe could be done with a lambda and an f-string.

first = "Reading"
last = "Rat"
deferred = lambda: f"{last}, {first}"
with_caching = functools.cache(lambda: f"{last}, {first}")
# or 
@functiols.cache
def cached_deferres():
    return f"{last}, {first}"

The syntax isn't great, especially if you also want caching on first  evaluation, but it is possible.

I generally keep running into situations, where I wish that Python had lazy-evaluating values, i.e. the equivalent of the cached functions above with arbitrary expressions, but with the evaluation being implicit when the value is actually used for something.

It would probably be possible to write a proxy class with that behavior, but typing support would be a big issue, and I'm not sure it is possible to get type(deferred_obj) return the type of the result or — better — a deferred value itself.

E.g. 

if deferred:
    ...

would need to evaluate the deferred expression, as does deferred + 1 unless explicitly deferred itself, but func(deferred) or list0.append(deferred) wouldn't need to evaluate it.

But with the available syntax it would again require something verbose like

deferred = LazyProxy(lambda: f"{last}, {first}")