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: 
Scala knows the arity of the tuples and is thus able to provide accessors like `_1`, `_2`, etc., and produce a compile-time error if you select `_3` on a pair, for instance. Moreover, the type of those fields is exactly what the type used as parameter for `Tuple` (e.g. `_3` on a `Tuple3[Int, Double, Float]` will return a `Float`).

If you want to access the nth element, you can write `tuple.productElement(n)`, but the return type of this can only be `Any`, so you lose the type information.
I believe the following excerpt from "Programming in Scala: A Comprehensive Step-by-Step Guide" (Martin Odersky, Lex Spoon and Bill Venners) directly addresses both of your questions:

> 
> **Accessing the elements of a tuple**
> 
> 
> You may be wondering why you can't access the elements of a tuple like
>  the elements of a list, for example, with "pair(0)". The reason is
>  that a list's apply method always returns the same type, but each
>  element of a tuple may be a different type: \_1 can have one result
>  type, \_2 another, and so on. These \_N numbers are one-based, instead
>  of zero-based, because starting with 1 is a tradition set by other
>  languages with statically typed tuples, such as Haskell and ML.
> 
> 
> 

Scala tuples get very little preferential treatment as far as the language syntax is concerned, apart from expressions `'(' a1, ..., an ')'` being treated by the compiler as an alias for scala.Tuplen(*a1, ..., an*) class instantiation. Otherwise tuples do behave as any other Scala objects, in fact they are written in Scala as [case classes that range from Tuple2 to Tuple22](https://lampsvn.epfl.ch/trac/scala/browser/scala/tags/R_2_9_1_final/src//library/scala/Tuple2.scala#L1). Tuple2 and Tuple3 are also known under the aliases of Pair and Triple respectively:

```
 val a = Pair   (1,"two")      // same as Tuple2 (1,"two") or (1,"two") 
 val b = Triple (1,"two",3.0)  // same as Tuple3 (1,"two",3.0) or (1,"two",3.0)

```