When I try
    
    numpy.newaxis

the result gives me a 2-d plot frame with x-axis from 0 to 1. However, when I try using `numpy.newaxis` to slice a vector, 

    vector[0:4,]
    [ 0.04965172  0.04979645  0.04994022  0.05008303]
    vector[:, np.newaxis][0:4,]
    [[ 0.04965172]
    [ 0.04979645]
    [ 0.04994022]
    [ 0.05008303]]

Is it the same thing except that it changes a row vector to a column vector? 

Generally, what is the use of [`numpy.newaxis`][1], and in which circumstances should we use it?


  [1]: https://numpy.org/devdocs/reference/constants.html#numpy.newaxis

How does numpy.newaxis work and when to use it?

I have two numpy arrays of different shapes, but with the same length (leading dimension). I want to shuffle each of them, such that corresponding elements continue to correspond -- i.e. shuffle them in unison with respect to their leading indices.

This code works, and illustrates my goals:
    

    def shuffle_in_unison(a, b):
        assert len(a) == len(b)
        shuffled_a = numpy.empty(a.shape, dtype=a.dtype)
        shuffled_b = numpy.empty(b.shape, dtype=b.dtype)
        permutation = numpy.random.permutation(len(a))
        for old_index, new_index in enumerate(permutation):
            shuffled_a[new_index] = a[old_index]
            shuffled_b[new_index] = b[old_index]
        return shuffled_a, shuffled_b

For example:

    &gt;&gt;&gt; a = numpy.asarray([[1, 1], [2, 2], [3, 3]])
    &gt;&gt;&gt; b = numpy.asarray([1, 2, 3])
    &gt;&gt;&gt; shuffle_in_unison(a, b)
    (array([[2, 2],
           [1, 1],
           [3, 3]]), array([2, 1, 3]))

However, this feels clunky, inefficient, and slow, and it requires making a copy of the arrays -- I&#39;d rather shuffle them in-place, since they&#39;ll be quite large.

Is there a better way to go about this? Faster execution and lower memory usage are my primary goals, but elegant code would be nice, too.

One other thought I had was this:

    def shuffle_in_unison_scary(a, b):
        rng_state = numpy.random.get_state()
        numpy.random.shuffle(a)
        numpy.random.set_state(rng_state)
        numpy.random.shuffle(b)

This works...but it&#39;s a little scary, as I see little guarantee it&#39;ll continue to work -- it doesn&#39;t look like the sort of thing that&#39;s guaranteed to survive across numpy version, for example.



Better way to shuffle two numpy arrays in unison

Let&#39;s say I have a 1d numpy array

    a = array([1,0,3])

I would like to encode this as a 2D one-hot array 

    b = array([[0,1,0,0], [1,0,0,0], [0,0,0,1]])

Is there a quick way to do this?  Quicker than just looping over `a` to set elements of `b`, that is.

Convert array of indices to 1-hot encoded numpy array

What&#39;s the more pythonic way to pad an array with zeros at the end?

    def pad(A, length):
        ...

    A = np.array([1,2,3,4,5])
    pad(A, 8)    # expected : [1,2,3,4,5,0,0,0]

___

In my real use case, in fact I want to pad an array to the closest multiple of 1024.  Ex: 1342 =&gt; 2048,  3000 =&gt; 3072



Zero pad numpy array

Can someone explain exactly what the `axis` parameter in NumPy does?

I am terribly confused. 

I&#39;m trying to use the function `myArray.sum(axis=num)`

At first I thought if the array is itself 3 dimensions, `axis=0` will return three elements, consisting of the sum of all nested items in that same position. If each dimension contained five dimensions, I expected `axis=1` to return a result of five items, and so on. 

However this is not the case, and the documentation does not do a good job helping me out [(they use a 3x3x3 array so it&#39;s hard to tell what&#39;s happening)][1]


Here&#39;s what I did:


    &gt;&gt;&gt; e
    array([[[1, 0],
            [0, 0]],
    
           [[1, 1],
            [1, 0]],
    
           [[1, 0],
            [0, 1]]])
    &gt;&gt;&gt; e.sum(axis = 0)
    array([[3, 1],
           [1, 1]])
    &gt;&gt;&gt; e.sum(axis=1)
    array([[1, 0],
           [2, 1],
           [1, 1]])
    &gt;&gt;&gt; e.sum(axis=2)
    array([[1, 0],
           [2, 1],
           [1, 1]])
    &gt;&gt;&gt;

Clearly the result is not intuitive.


  [1]: http://pages.citebite.com/n2u9w2x6t5efl

How does the axis parameter from NumPy work?

Is there a convenient way to calculate percentiles for a sequence or single-dimensional numpy array?

I am looking for something similar to Excel&#39;s percentile function.

I looked in NumPy&#39;s statistics reference, and couldn&#39;t find this. All I could find is the median (50th percentile), but not something more specific.


How do I calculate percentiles with python/numpy?

In Python, how do I create a numpy array of arbitrary shape filled with all True or all False?

How to create a numpy array of all True or all False?

NumPy proposes a way to get the index of the maximum value of an array via `np.argmax`.

I would like a similar thing, but returning the indexes of the `N` maximum values.

For instance, if I have an array, `[1, 3, 2, 4, 5]`, `function(array, n=3)` would return the indices `[4, 3, 1]` which correspond to the elements `[5, 4, 3]`.


How do I get indices of N maximum values in a NumPy array?

A numpy matrix can be reshaped into a vector using reshape function with parameter -1. But I don&#39;t know what -1 means here.

For example: 

    a = numpy.matrix([[1, 2, 3, 4], [5, 6, 7, 8]])
    b = numpy.reshape(a, -1)

The result of `b` is: `matrix([[1, 2, 3, 4, 5, 6, 7, 8]])`

Does anyone know what -1 means here?
And it seems python assign -1 several meanings, such as: `array[-1]` means the last element. Can you give an explanation?



What does -1 mean in numpy reshape?

What are the advantages of [NumPy][1] over regular Python lists?

I have approximately 100 financial markets series, and I am going to create a cube array of 100x100x100 = 1 million cells. I will be regressing (3-variable) each x with each y and z, to fill the array with standard errors.

I have heard that for &quot;large matrices&quot; I should use NumPy as opposed to Python lists, for performance and scalability reasons. Thing is, I know Python lists and they seem to work for me. 

What will the benefits be if I move to NumPy?

What if I had 1000 series (that is, 1 billion floating point cells in the cube)? 

  [1]: http://en.wikipedia.org/wiki/NumPy


What are the advantages of NumPy over regular Python lists?

There is this https://stackoverflow.com/questions/312443/how-do-you-split-a-list-into-evenly-sized-chunks-in-python
for splitting an array into chunks. Is there anyway to do this more efficiently for giant arrays using Numpy?

Partition array into N chunks with Numpy

Can someone explain to me what is the purpose of `meshgrid` function in Numpy? I know it creates some kind of grid of coordinates for plotting, but I can&#39;t really see the direct benefit of it.

I am studying &quot;Python Machine Learning&quot; from Sebastian Raschka, and he is using it for plotting the decision borders. See input 11 [here][1].

I have also tried this code from official documentation, but, again, the output doesn&#39;t really make sense to me.

    x = np.arange(-5, 5, 1)
    y = np.arange(-5, 5, 1)
    xx, yy = np.meshgrid(x, y, sparse=True)
    z = np.sin(xx**2 + yy**2) / (xx**2 + yy**2)
    h = plt.contourf(x,y,z)

Please, if possible, also show me a lot of real-world examples.




  [1]: https://github.com/rasbt/python-machine-learning-book/blob/master/code/ch03/ch03.ipynb

What is the purpose of meshgrid in Python / NumPy?

    import numpy as np
    y = np.array(((1,2,3),(4,5,6),(7,8,9)))
    OUTPUT:
    print(y.flatten())
    [1   2   3   4   5   6   7   8   9]
    print(y.ravel())
    [1   2   3   4   5   6   7   8   9]
Both function return the same list.
Then what is the need of two different functions performing same job.

What is the difference between flatten and ravel functions in numpy?

Alright, I&#39;m toying around with converting a PIL image object back and forth to a numpy array so I can do some faster pixel by pixel transformations than PIL&#39;s `PixelAccess` object would allow.  I&#39;ve figured out how to place the pixel information in a useful 3D numpy array by way of:

    pic = Image.open(&quot;foo.jpg&quot;)
    pix = numpy.array(pic.getdata()).reshape(pic.size[0], pic.size[1], 3)

But I can&#39;t seem to figure out how to load it back into the PIL object after I&#39;ve done all my awesome transforms.  I&#39;m aware of the **`putdata()`** method, but can&#39;t quite seem to get it to behave.


How to convert a PIL Image into a numpy array?

Pretty much what the title says. I&#39;ve read the documentation and I&#39;ve played with the function for a while now but I can&#39;t discern what the physical manifestation of this transformation is. 

What is an intuitive explanation of np.unravel_index?

I have two simple one-dimensional arrays in [NumPy][1]. I should be able to concatenate them using [numpy.concatenate][2]. But I get this error for the code below:

&gt; TypeError: only length-1 arrays can be converted to Python scalars


### Code

    import numpy
    a = numpy.array([1, 2, 3])
    b = numpy.array([5, 6])
    numpy.concatenate(a, b)

Why?

  [1]: http://en.wikipedia.org/wiki/NumPy
  [2]: http://docs.scipy.org/doc/numpy/reference/generated/numpy.concatenate.html


Concatenating two one-dimensional NumPy arrays

What is the difference between `ndarray` and `array` in Numpy? And where can I find the implementations in the numpy source code?

What is the difference between ndarray and array in numpy?

What is the status of the `matrix` class in NumPy?

I keep being told that I should use the `ndarray` class instead. Is it worth/safe using the `matrix` class in new code I write? I don&#39;t understand why I should use `ndarray`s instead.


Deprecation status of the NumPy matrix class

I have a simple question about the .shape function, which confused me a lot. 

    a = np.array([1, 2, 3])   # Create a rank 1 array
    print(type(a))            # Prints &quot;&lt;class &#39;numpy.ndarray&#39;&gt;&quot;
    print(a.shape)            # Prints &quot;(3,)&quot;
    
    b = np.array([[1,2,3],[4,5,6]])    # Create a rank 2 array
    print(b.shape)                     # Prints &quot;(2, 3)&quot;

What did the .shape exactly do? count how many rows, how many columns,
then the a.shape suppose to be, (1,3), one row three columns, right?





All Numpy Ndarray Solutions on Gang of Coders

Total of 19 Numpy Ndarray Solutions