Sigma notation but each result is stored in a new sequence of equal length (no adding) My background is Computer Science, so I recognise $\Sigma$ as a for loop that exclusively sums, returning one element/ answer.
What is the notation used to loop over a finite sequence, to perform any calculation, and store the output into a new sequence of equal length?
i.e. I don't want to add each iteration's answer together. One element should yield one unique answer.

All of your comments and answers have given me brilliant insight. I will still be working on this problem as good old fashioned practice. Thank you all.
 A: General Comment
Outside of a block of pseudocode describing an algorithm, mathematical notation is basically stateless. Rather than an imperative programming style which would have things like "for loops", mathematics is usually written like a declarative style. Because of this, the verb "store" (as in "store the output") doesn't really match up with any standard mathematical notation.
Main Answer
If the operation only involves the current entry in the sequence, then variations of the the idea in Blue's comment would be common. Define $f$ to be the function that outputs the "any calculation", and define something like $a_0,a_1,\ldots,a_n$ to be the initial entries of the sequence. Then the new sequence could be written like $\left(\;f(a_k)\;\right)_{k=0}^n$ or $\left\langle f\left(a_k\right)\right\rangle_{k}$, etc., depending on the author's personal style.
To answer a follow-up comment, the sequence can be indexed in whatever way suits your needs in context. For example $a_7,a_8,a_9$ and $\left(\;f\left(a_k\right)\;\right)_{k=7}^9$ would be fine. If the original sequence is a subsequence of some sequence discussed earlier, you could even write things like $\left\langle f\left(a_{k^2-k}\right)\right\rangle_{k=1}^{17}$. In practice, you often might not have need to bundle the sequence together like this, and might just write things like "Let $b_n=f(a_n)$ for all $n\in\left\{7,\ldots,93\right\}$."
Also, this notation has no trouble with infinite sequences. For example:

Define $b_n$ to be $n!$ (the factorial), and define $f(k)=k^3$. Then define $c_n=f(b_n)$ for all $n$. Note that the infinite sequence $\left\langle c_n\right\rangle_{n=1}^{\infty}$ grows even faster than the $a_n$ do.

Sums
As mentioned before, mathematics isn't really written in an imperative way. So mathematical sums with $\sum$ are not best thought of as a for loop. Instead, I would say that the approach in mathematics is often similar to functional programming. With that in mind, $\sum$ is probably most analogous to a fold/reduce with the addition operation and $0$ as the empty sum.
${\displaystyle \sum_{i=1}^{1000}} 2i$ could correspond to things like foldr (+) 0 [2*i | i<-[1..10^3]] in Haskell (Try it online!). In Python, the equivalent (inspired by this SO answer) would be reduce(add, [2*i for i in range(1,10**3+1)], 0) (Try it online!) using the functools and operator modules (and ignoring the existence of sum).
A: The sum $\sum_{k=0}^{n-1}a[k]$ over a length-$n$ iterable (let's say an array) $a$ can be achieved in Python as functools.reduce(operator.add, a). Your question is effectively how a mathematician would denote functools.reduce(f, a) for an arbitrary binary function $f$ (unless you only care about how it's said in programming instead, in which case I've already answered that, albeit somewhat stepping on @MarkS.'s toes in doing so).
I don't think there is a general notation. Some special cases have an equivalent of $\sum$, such as $\prod$ for multiplication, $\bigcup$ ($\bigcap$) for sets' unions (intersections), and so on. The best option would be to explicitly define something analogous to partial sums. So let's define partial calculations $C_n$ by$$C_1:=a_0,\,C_{k+1}:=f(C_k,\,a_k)$$(forgive the $+1$s; they result from me using Python, which is $0$-indexed, in the above example, but then many (most?) programming languages are $0$-indexed). In practice, you'd have to present this definition to your readers.
The sum I gave in Python could be written as functools.reduce(operator.add, a, 0). This allows a length-$0$ choice of a to be supported. The equivalent for multiplication is functools.reduce(operator.mul, a, 1). The extra argument checks because $0+x=1\times x=x$. General $f$ won't have a left-identity, which is why I started with $C_1$ rather than $C_0$, which would have to be the left-identity. (We call $0$ an empty sum; we call $1$ an empty product.)
