Question: > 
> *In mathematics and computer science, a tuple is an ordered list of elements. In set theory, an (ordered) n-tuple is a sequence (or ordered list) of n elements, where n is a positive integer.*
> 
> 
> 

So, for example, in Python the 2nd item of a tuple would be accessed via `t[1]`.

In Scala, access is only possible via strange names `t._2`.

So the question is, why can't I access data in tuples as Sequence or List if it is by definition? Is there some sort of idea or just yet not inspected?

Answer: 
One big difference between `List`, `Seq` or any collection and tuple is that in tuple each element has it's own type where in List all elements have the same type.

And as consequence, in Scala you will find classes like `Tuple2[T1, T2]` or `Tuple3[T1, T2, T3]`, so for each element you also have type parameter. Collections accept only 1 type parameter: `List[T]`. Syntax like `("Test", 123, new Date)` is just syntactic sugar for `Tuple3[String, Int, Date]`. And `_1`, `_2`, etc. are just fields on tuple that return correspondent element.
With normal index access, any expression can be used, and it would take some serious effort to check at compiletime if the result of the index expression it is guaranteed to be in range. Make it an attribute, and a compile-time error for `(1, 2)._3` follows "for free". Things like allowing only integer constants inside item access on tuples would be a very special case (ugly and unneeded, some would say ridiculous) and again some work to implement in the compiler.

Python, for instance, can get away with that because it wouldn't (couldn't) check (at compiletime, that is) if the index is in range anyway.