Why should irrational numbers like PI not be countable? There is an algorithm that can calculate PI, and algorithms are countable, which is obvious since it can be stored on a hard drive in a certain format, that can also be interpreted as one large number.
Therefore, irrational numbers that have an algorithm must be countable too. And since I doubt that there is a number that cannot be calculated. I assume that all irrational numbers are countable.
I'm not a mathematician and therefore assume that there is something fundamental wrong with my argument, but I would like to know what it is.
 A: My favorite example of a non-computable number can be found here.
What you have touched on is the definition of computable numbers. These are numbers which, informally, can be output by a computer running some program. A technical definition is as follows (copied from the wikipedia page)

A real number a is computable if it can be approximated by some computable function $f:\mathbb {N} \to \mathbb {Z }$ in the following manner: given any positive integer $n$, the function produces an integer $f(n)$ such that:
$${f(n)-1 \over n}\leq a\leq {f(n)+1 \over n}$$

All this definition basically says is that given enough time, a computer can spit out as many digits of the number as you wish (although obviously not all of them). Do non-computable numbers exist? You bet, and here is an existence proof (although I will hand wave some of the details)
Theorem: The set of computable numbers is countable
Proof: By definition, every computable $x$ number corresponds to some computer program which will spit out $n$ digits of $x$ after $n$ steps (this is one part I am hand waving). But the set of all computer programs is countable since every computer program can be defined in a finite number of symbols. To get some intuition about why this is true (again, I am hand waving some of the finer details) try to imagine writing a computer program:
$1)$ Pick a language (Python for example)
$2)$ Type the symbols that Python recognizes (a key point, it only recognizes a finite number of symbols)
$3)$ Run the program after you are finished typing
The key idea is that every program is made up of a finite number of symbols picked from a finite language. Thus, there are only a finite number of programs that can be written (for example in Python) with length less than $100$ symbols. Do these programs do anything interesting? Probably not, but the key point is that you can list them all if you really wanted to. Thus, the set of all computer programs is countable: list the programs with less than $10$ symbols, then add the programs with less than $100$ symbols to this list, then $1000$ symbols and so on. Since the program that defines the computable number $x$ must be somewhere in this list, and $x$ was an arbitrary computable number, we conclude the set of computable numbers is countable.
A: The issue with your argument is the assumption that every irrational number has an algorithm to compute it. Unfortunately, this is known to be false. The proof that numbers exist without such algorithms is elegant, but it requires knowledge of the Halting Problem. For the purposes of this answer, I will be very imprecise.
The Halting Problem
The Halting Problem asks the following question - is there an algorithm $X$ that takes as input another algorithm $Y$ and some other input $A$ and returns $1$ if the algorithm $Y$ terminates while computing on input $A$ and $0$ if $Y$ computes forever. In symbols, $X(Y,A)=1$ if $Y\downarrow A$ and $X(Y,A)=0$ otherwise. To see that such an algorithm doesn't exist, we can write an algorithm $Z$ that has access to $X$ and loops if $X(Z,Z)=1$ and immediately halts if $X(Z,Z)=0.$ Now if $X(Z,Z)=1$ is actually true, $Z$ will loop forever and never terminate, but this implies that $X(Z,Z)=0$ by the definition of $X,$ a contradiction. On the other hand, if $X(Z,Z)=0$ is true, we know that $Z$ will immediately halt, but this implies $X(Z,Z)=1,$ another contradiction. Since the existence of $X$ allows us to write this contradictory algorithm $Z,$ it must be the case that $X$ does not exist.
The Busy Beaver Function
The easiest example of a non-computable number comes from counting the number of steps that each algorithm of a fixed size can compute before halting. This counting is called the Busy Beaver Function and is given the symbol $\Sigma$. It takes a natural number $k$ as input and returns the maximum number of steps an algorithm of length $k$ can take before halting when given no input. This function doesn't have an algorithm either. If it did, then we could solve the halting problem as follows. Given an algorithm $Y$ and input $A$, we can write a new algorithm $Y[A]$ which takes no input and runs the algorithm $Y$ on input $A.$ We can then measure the size $k$ of $Y[A]$ and run the algorithm to calculate $\Sigma(k).$ Now we can simply run $Y[A]$ for $\Sigma(k)$ steps and see if it has terminated. If so, then we know it halts and we can return $1$, otherwise, since all algorithms of size $k$ terminate in $\Sigma(k)$ steps or less, it must be that $Y[A]$ never halts so we can return a $0.$
A Non Computable Number
The Busy Beaver Function can be used directly to define a non computable number. First, it's important to note that $\Sigma$ is strictly increasing. This implies that the $n$th smallest element of the image of $\Sigma$ is the value of $\Sigma$ at $n.$ It also implies that the following sum contains only ones and zeros in its decimal expansion
$$C=\Sigma_{k=0}^{\infty}10^{-\Sigma(k)}$$
where the outer "$\Sigma$" denotes a sum and the inner "$\Sigma$" denotes the Busy Beaver Function. If $C$ were computable, then we could compute $\Sigma(k)$ for any $k$ by simply computing more and more digits of $C$ until we find the $k$th occurrence of $1$. The integer representing the location of the $k$th occurrence of $1$ is then the value of $\Sigma(k).$ However, we know that $\Sigma$ is not computable because the Halting Problem is not decidable, and so it must be the case that $C$ is a non-computable real number.
A Note on Irrationality
Though I haven't worked through the details, I believe $C$ to be a transcendental number. It's known that the growth rate of the Busy Beaver function is asymptotically greater than any computable function. In particular, the spacing of the ones in the decimal expansion of $C$ grows faster than the spacing of the ones in Liouville's Constant, for which the $k!$th digit is a $1$ for each $k\in\mathbb{N}.$ I believe this is enough to satisfy the Liouville inequality, implying that $C$ is in fact a Liouville Number.
