Why I cannot shorten a GameObject property into a variable?
... shorten a GameObject property into a variable?

what do you mean with shorten?
Game Object Properties
A property consists at least of a property name and a property value (it has an owner too).
Within the BGE you do not have direct access to a game object property. Therefore a property is no object to be used. What you can get is the property's value.
You get the value by key access:
value = gameObject[&quot;property name&quot;]

or
value = gameObject.get(&quot;property name&quot;)

The goal is to get the value. After getting the value the property name is usually not of further interest unless you want to change the property.
Write access means you assign a new value:
gameObject[&quot;property name&quot;] = newValue

If the property did not exist before it adds a new one, otherwise it replaces the value.
This way the game object behaves like a dictionary, with property names as keyword and property values as values.
Your question

obj[&quot;prop&quot;] = value

These is (as described above) a write access to the property with name &quot;prop&quot;. It assigns the object referred by variable value as property value.

prop = obj[&quot;prop&quot;] 
prop = value


This creates a variable named prop and assigns the value read from property named &quot;prop&quot;.
The second line creates a new variable named propassigning the object referred by variable value. The variable of the first line is gone (life time ended).
Investigation
I guess you think you can manipulate properties without using the write access. This is not possible. You can manipulate the value (which is an object) but assigning a new value has to be an write operation.
Example:
Lets assume you have a property called &quot;amount&quot;. The value is 5.
gameObject[&quot;amount&quot;] = 5

At a later stage you want to change the value from 5 to 4.
How can you do that?
You can't change a 5 to a 4.
A 5 is an int constant. It has no operation to change it's value. So you need to assign a separate value (other object) to the property that represents 4.
The code will be:
gameObject[&quot;amount&quot;] = 4

This is a restriction of immutable objects. You can't change them. Immutable objects are string, int, bool, float and more. Basically the basic object types.
What with mutable objects? Here you can manipulate the object as often as you like without notifying the container it lives in.
Example:
Lets assume you have a property called &quot;last position&quot;. The value is a Vector(0,0,0).
gameObject[&quot;last position&quot;] = mathutils.Vector([0,0,0])

To get the position object you read it from the property:
lastPosition = gameObject[&quot;last position&quot;]

now you can manipulate lastPosition as much as you like:
lastPosition.x = 1.2
lastPosition.y = 2
lastPosition.length = 10.3

You do not need to assign lastPosition back to the property. The object is still the same, but with other content.
This &quot;referring&quot; effects do not just apply to game object properties. This applies to all containers e.g. list, dict, even module. They store a reference to a specific object. You can manipulate the object without reassigning. If you reassign the object, you assign the same reference again.
Be aware the variable refers to the property value. Assigning a different object to the variable will not manipulate the property. The container (game object) does not know about your variables.
Negative Example:
lastPosition = gameObject[&quot;last position&quot;]
lastPosition = mathutils.Vector([1.2, 2, 0])

The first line:

creates a variable called lastPosition and assigns the property value.

The second line:

creates a variable called lastPosition and assigns a new vector object.
The variable lastPosition of the first line is gone and will be freed by the garbage collector.
The property value still exist, but variable lastPosition does not refer to it. It refers to a different vector object (the one from last line).