subscripts in sympy and python

I'm learning sympy and python by studying sample codes I found online. I came across this line of code

z = symbols("z_{0:2}")

which creates the variables z_0 and z_1. This is very handy! Now, the z_{0:2} construction reminds me of the range function in basic python. My question: Is this z_{0:2} an ad-hoc trick just for defining variables with subscripts, or is this a special instance of a general sympy/python construction? If so, what is this general construction, and can you point me to a couple of onlin documentation where I can learn more about this?

I'm a complete newbie; thanks for your patience.

The documentation of the symbols function is well written with plenty of examples, so I'm not going to repeat it here.

The "range syntax" is implemented by this function in order to reduce typing while creating indexed elements. Note that I used the word "elements" and not "symbols", because the symbols function can be used to create ordinary symbols, wild symbols (for pattern matching), undefined functions, indexed objects, etc. For example:

s1, s2, s3, s4, s5 = symbols("s1:6")
f1, f2, f3, f4, f5 = symbols("f1:6", cls=Function)
i1, i2, i3, i4, i5 = symbols("i1:6", cls=Idx)

Note that:

1. I haven't used curly parentheses in the above examples.
2. there is no _ (underscore) character between the actual name and the numeric subscript.
3. If you are using an interactive environment which render latex (for example, Jupyter Notebook), you will see that the above symbols and function will be rendered with a subscript. That's the default behavior of the LatexPrinter.

Underscores and curly parentheses can be used to create more complicated-looking symbols. For example, if I want to create a symbol representing the temperature of hydrogen inside a tank I would do something like this:

T = symbols("T_{H_{2}}^{tank}")
T

This renders nicely on an interactive environment, but it would be very hard to understand on a non-interactive environment.

EDIT to satisfy comment: it really depends on what you are trying to achieve. For example, using a list of symbols:

N = 6
z = symbols("z_{0:%s}" % N) # list of symbols
sum([z[(-1)**n + 1] for n in range(N)])
# out: 3*z_{0} + 3*z_{2}

or using an indexed object:

N = 5
z = IndexedBase("z")
expr = Sum(z[(-1)**n + 1], (n, 0, N))
print(expr)
# out: Sum(z[(-1)**n + 1], (n, 0, 5))
print(expr.doit())
# out: 3*z[0] + 3*z[2]

If you look at the latex rendered on the screen, the last output of both examples are identical, yet they are conceptually very different.