←back to thread

I don't like NumPy

(dynomight.net)
480 points MinimalAction | 3 comments | 15 May 25 16:05 UTC | HN request time: 0s | source
Show context
aborsy ◴[15 May 25 19:10 UTC] No.43998278[source]▶
My main problem with numpy is that the syntax is verbose. I know from the programming language perspective it may not be considered a drawback (might even be a strength). But in practice, the syntax is a pain compared to matlab or Julia. The code for the latter is easier to read, understand, consistent with math notation.
replies(1): >>43998865 #
nis251413 ◴[15 May 25 20:15 UTC] No.43998865[source]▶
The syntax of actual array languages can be beautifully concise and expressive. You can express mathematical formulas in ways that makes sense when you read a single line, and once you get used to the notation and some originally non-intuitive quirks (from a programming background perspective), you can write in very few lines what otherwise would take you several lines of rather ugly, less readable code.

In my view, python+numpy is not actually an array language. Numpy as a library adds vectorization operations to python in order to help with speed. This is different. It does not (intend to) bring the advantages that array language syntax has, even if it was a bit more consistent.

replies(2): >>43999809 #>>44001667 #
1. aborsy ◴[16 May 25 03:47 UTC] No.44001667[source]▶
Yeah. Compare

A = [1, 2; 3, 4];

x = [5; 6];

y = A * x;

with this uglier version:

import numpy as np

A = np.array([[1, 2], [3, 4]])

x = np.array([[5], [6]])

y = A @ x

replies(1): >>44002003 #
2. threeducks ◴[16 May 25 05:07 UTC] No.44002003[source]▶
You don't have to wrap the lists in np.array if you use NumPy functions (or if one of the arguments already is a NumPy array, which usually is the case):

    from numpy import *

    A = [[1, 2], [3, 4]]
    x = [[5], [6]]
    y = dot(A, x)
replies(1): >>44010217 #
3. nis251413 ◴[16 May 25 22:10 UTC] No.44010217[source]▶
That's nice, but only works, as I understand it, if you use numpy-only functions, which means that you should not use those who denote also base-pythonic, eg +,* etc operations, because then they are interpreted differently. Eg `A + x` gives

    [[1, 2], [3, 4], [5], [6]]
instead of

    array([[ 6,  7],[ 9, 10]])
You have to keep track of the context there to know what you can do and what not I guess, which is not ideal.