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: 
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)

```
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.