Under “normal” circumstances, both approaches are equivalent.
In other words, whether you use a value through an explicit expression (eg,
np.identity(3, dtype = np.double)/3.0) or through a variable-name that has been initialized with that expression (here,
a), the outcome would “normally” be the same.
There are some not-so-normal circumstances, where they may produce different results. As far as I can see all these have to do with situations in which there are side-effects such that the outcome depends upon the order in which things happen. For example:
Consider a scenario where the initialization of the variable-name
b involves a side-effect that affects the initialization of the variable-name
a. And let’s say your code depends on that side-effect. In this scenario, in the case of the fist approach (where you first initialize the variable-names and then use only those variables), your code would have to initialize
b first, and
a later — the order of the initialization of the variable-names matters. In the second approach (where you would have explicit expressions rather than variable-names, participating in a larger expression), to achieve the same effect, you will have to pay attention to the order in which Python interpreter evaluates sub-expressions within an expression. If you don’t, then the order of evaluation of sub-expressions may not produce the side-effect that your code needs, and you might end up getting a different result.
As for other programming languages the answer is a big yes, the two approaches can yield different results, in languages (such as Java), where the variable-names have associated data-types, which can cause some silent numerical conversions (such as truncations) to happen during variable-assignment.
CLICK HERE to find out more related problems solutions.