Yes, I'm aware sequence unpacking.
There is an overlap like you mentioned, but there are things that can't be done with sequence unpacking, but can be done here.
For example, let's say you're given two lists that are not necessarily numbers, so you can't use numpy, but you want to apply some component-wise operator between each component. This is something you can't do with sequence unpacking or with numpy.
Yes, you can do it with numpy.
Obviously you don't get the performance benefits when you aren't using "native" types (like int32) and operations that have vectorizes implementations (like adding two arrays of int32 or taking the dot product of float64 matrices), but you do still get the same elementwise operators, and even a way to apply arbitrary callables over arrays, or even other collections:
>>> firsts = ['John', 'Jane']
>>> lasts = ['Smith', 'Doe']
>>> np.vectorize('{1}, {0}'.format)(firsts, lasts)
array(['Smith, John', 'Doe, Jane'], dtype='<U11)
That's everything you're asking for, with even more flexibility, with no need for any new ugly perlesque syntax: just use at least one np.array type in an operator expression, call a method on an array type, or wrap a function in vectorize, and everything is elementwise.
And of course when you actually _are_ using numbers, as in every single one of your examples, using numpy also gives you around a 6:1 space and 20:1 time savings, which is a nice bonus.
For example:
$StudentFullName = $FirstName + " " + $LastName
So, in effect, I think one big part of is component wise operations.
Another thing that can't be achieved with sequence unpacking is:
f($x)
i.e. applying f for each component of x.
That's a very different operation, which I think is more readably spelled map(f, x).
About your question above, it's not ambiguous here either:
a; b = x1;a + x2;5
is exactly "Equivalent" to
a = x1+x2
b = a + 5
Also, there is a difference in style in sequence unpacking, and here.
In sequence unpacking, you have to pair up the right variables and repeat the operator, for example:
x,y,z = x1+x2 , y1+y2, z1+z2
Here you don't have to repeat it and pair up the right variables, i.e.
x;y;z = x1;y1;z1 + x2;y2;z2
If you only have two or three of these, that isn't a problem. Although in this case, it sure looks like you're trying to add two 3D vectors, so maybe you should just be storing 3D vectors as instances of a class (with an __add__ method, of course), or as arrays, or as columns in a larger array, rather than as 3 separate variables. What could be more readable than this:
v = v1 + v2
And if you have more than about three separate variables, you _definitely_ want some kind of array or iterable, not a bunch of separate variables. You're worried about accidentally typing "y1-y2" when you meant "+", but you're far more likely to screw up one of the letters or numbers than the operator. You also can't loop over separate variables, which means you can't factor out some logic and apply it to all three axes, or to both vectors. Also consider how you'd do something like transposing or pivoting or anything even fancier. If you've got a 2D array or iterable of iterables, that's trivial: transpose or zip, etc. If you've got N*M separate variables, you have to write them all individually. Your syntax at best cuts the source length and opportunity for errors in half; using collections cuts it down to 1.