Use numpy.linalg.norm:

dist = numpy.linalg.norm(a-b)

This works because the Euclidean distance is the l2 norm, and the default value of the ord parameter in numpy.linalg.norm is 2. For more theory, see Introduction to Data Mining:

They are both correct as they calculate the same thing but the numpy one should be much faster (you may want to time them to see this). In general your own implementation is very clumsy as it uses a for loop which is unnecessary. If you want to create your own implementation (though it still likely wont be as fast as numpy's one) then vectorize it and do something like:

def EuclideanDistance1(vector1, vector2):
   dist = np.sqrt(np.sum((vector1 - vector2)**2))
   return dist

but I would just use: https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.euclidean.html

A norm is a function that takes a vector as an input and returns a scalar value that can be interpreted as the "size", "length" or "magnitude" of that vector. More formally, norms are defined as having the following mathematical properties:

• They scale multiplicatively, i.e. Norm(a·v) = |a|·Norm(v) for any scalar a
• They satisfy the triangle inequality, i.e. Norm(u + v) ≤ Norm(u) + Norm(v)
• The norm of a vector is zero if and only if it is the zero vector, i.e. Norm(v) = 0 ⇔ v = 0

The Euclidean norm (also known as the L² norm) is just one of many different norms - there is also the max norm, the Manhattan norm etc. The L² norm of a single vector is equivalent to the Euclidean distance from that point to the origin, and the L² norm of the difference between two vectors is equivalent to the Euclidean distance between the two points.

As @nobar's answer says, np.linalg.norm(x - y, ord=2) (or just np.linalg.norm(x - y)) will give you Euclidean distance between the vectors x and y.

Since you want to compute the Euclidean distance between a[1, :] and every other row in a, you could do this a lot faster by eliminating the for loop and broadcasting over the rows of a:

dist = np.linalg.norm(a[1:2] - a, axis=1)

It's also easy to compute the Euclidean distance yourself using broadcasting:

dist = np.sqrt(((a[1:2] - a) ** 2).sum(1))

The fastest method is probably scipy.spatial.distance.cdist:

from scipy.spatial.distance import cdist

dist = cdist(a[1:2], a)[0]

Some timings for a (1000, 1000) array:

a = np.random.randn(1000, 1000)

%timeit np.linalg.norm(a[1:2] - a, axis=1)
# 100 loops, best of 3: 5.43 ms per loop

%timeit np.sqrt(((a[1:2] - a) ** 2).sum(1))
# 100 loops, best of 3: 5.5 ms per loop

%timeit cdist(a[1:2], a)[0]
# 1000 loops, best of 3: 1.38 ms per loop

# check that all 3 methods return the same result
d1 = np.linalg.norm(a[1:2] - a, axis=1)
d2 = np.sqrt(((a[1:2] - a) ** 2).sum(1))
d3 = cdist(a[1:2], a)[0]

assert np.allclose(d1, d2) and np.allclose(d1, d3)

From what I can see in the DocString of np.linalg.norm, it looks like for arrays with dim>2, it takes the largest singular value for ord=2, meaning np.linalg.norm(a, ord=2) is the same as np.linalg.svd(a)[1].max(). So in your case that's gonna be:

print(np.sqrt(np.sum(np.square(a-b))))
print(np.linalg.norm(a-b, 2))
print(np.linalg.svd(a-b)[1].max())

And this will return 5.385, 5.339, 5.339.

The mathematical formulation is given on Wikipedia, where the distinction is made between 2-norm (which is ord=2) and Frobenius norm (ord=None).