Shouldn't the matrix of eigen vectors of a defective matrix be non-invertible?

Is it true that a defective (non-diagonalizable) square matrix has a set of eigen vectors that don't span the whole space? In that case, if we do its singular value decomposition, shouldn't the matrix containing the eigen vectors be less than full rank and hence non-invertible?

If this is true, I'm getting a contradiction. Based on this page: What kind of matrices are non-diagonalizable?, the matrix:

$$A = \pmatrix{ 2 & 1\\ 0 & 2 }$$

is non-diagonalizable.

Now, I get its eigen matrix in python and try to invert it and nothing explodes.

import numpy as np
a=np.array([[2,1],[0,2]])
np.linalg.inv(np.linalg.svd(a)[0])


What am I missing?

EDIT: Here are the $$U$$ matrix, diagonal eigen values and $$V$$ matrix returned by Python. Are they incorrect? Should we even expect the $$U$$ and $$V$$ matrices to be non-invertible in this case?

u=[[ 0.78820544, -0.61541221],
[ 0.61541221,  0.78820544]]
lambda=[2.56155281, 1.56155281],
v=[[ 0.61541221,  0.78820544],
[-0.78820544,  0.61541221]]

• For your matrix, eigenvectors are just multiples of $[1,0]^T$ with eigenvalue $2$. So of course the resulting $2 \times 1$ matrix is "non-invertible". Is this, then, a question about Python or something? Jan 20 at 19:20
• When you say nothing explodes, does the returned inverse matrix actually function as an inverse? Or is it rather a Moore-Penrose pseudoinverse, or perhaps just some junk? Jan 20 at 19:33

svd doesn't calculate the eigenvector matrix; it calculates the Singular Value Decomposition. For singular values, it doesn't matter whether $$A$$ itself is diagonalizable, but that self-adjoint operator $$A^*A = \begin{pmatrix} 4 & 2 \\ ​2 & 5 \end{pmatrix}$$ is diagonalizable, and it is.

The answer by @Dan is spot on. I should have been looking for the eigen decomposition, not the singular value decomposition. And if I do that with python, I get an Eigen matrix whose inverse explodes as expected.

(code continues from the question)

np.linalg.eig(a)


produces:

(array([2., 2.]),
array([[ 1.0000000e+00, -1.0000000e+00],
[ 0.0000000e+00,  4.4408921e-16]]))