[Atwood's Law]
This was inevitable I guess, but does anyone know if there's a decent Pandas equivalent for Javascript? I'd love to be able to handle reasonably large datasets in Javascript as easily as I can in Python.
This was inevitable I guess, but does anyone know if there's a decent Pandas equivalent for Javascript? I'd love to be able to handle reasonably large datasets in Javascript as easily as I can in Python.
A quick search brought me here(https://stackoverflow.com/questions/30610675/python-pandas-e...) and here (https://stratodem.github.io/pandas.js-docs/#introduction)— not sure pandas-js is maintained any longer, though.
edit: In that SO question, there's a pointer to Apache Arrow which appears to be maintained more regularly, with types—and library support for multiple languages. Never used it, myself, though.
JS can be verbose, but I find that functional style JS is, in my opinion, a bit more readable than Python list comprehensions.
???
Python does all of that. There are native map/reduce/filter methods in the standard library.
>>> x = [1, 2, None, 3]
>>> list(filter(None, x))
[1, 2, 3]
>>> list(map(float, [1, 2, 3]))
[1.0, 2.0, 3.0]
>>> double = lambda x: x * 2
>>> list(map(double, range(3)))
[0, 2, 4]
Once you have something sufficiently complex (such as using map, filter, and reduce all at the same time), there becomes so much line noise that it starts working against you.
With JS/Ruby/Scala, you chain functional methods as opposed to Python where you can keep wrapping functions.
Something like
let arr = [0,1,2,'test'];
arr
.filter(x => typeof(x) == 'number')
.map(x => x*2)
.reduce((x, y) => x * y)
from functools import reduce
arr = [0,1,2,'test']
# with lambdas
reduce(lambda x,y: x + y, map(lambda x: x * 2, filter(lambda x: type(x) == int, arr)))
# list comprehension equivalent
sum([x * 2 for x in arr if type(x) == int])
> a = np.array([1, 2, 3, 4, 5])
> a * 10
array([10, 20, 30, 40, 50])
> a[a < 3]
array([1, 2])
> a1 = 1:5
> a2 = c(2, 4, 6, 8, 10)
> a1 + a2
3 6 9 12 15
> df["New Column Name"] = df.Col1 * (df.Col2 / df.Col3) let a = [1, 2, 3, 4, 5]
> a.map(x => x * 10)
(5) [10, 20, 30, 40, 50]
> a.filter(x => x > 3)
(2) [4, 5]
> a1.map((x,i) => x + a2[i])
(5) [3, 6, 9, 12, 15]
For JS, something similar to pandas creating a new column based on operations of other columns would be to do map an array of objects (list of dicts) and use a (Schwartzian_transform)[https://en.wikipedia.org/wiki/Schwartzian_transform] to create a new object property. I would love to look into how efficient these sort of operations can be, have had some success with this sort of thing for performing cosine similarity in the browser instead of creating sparse matrices with python.
But for simpler operations, if you're doing a lot of vector computations, then map and filter bloat the code considerably when the mathematical notation is easy to read.
Good luck with work on the JS implementation and efficiency comparisons. Pandas utilizes a Series object built on top of NumPy array for handling columns and rows. I don't know whether a similar approach would be helpful in JS.
A review of some options here.