从 numpy“数组”的每个元素中减去 0.5

Question

With "a" a numpy array, sometimes

a = a - 0.5 

works, sometimes it doesn't. There are several variations on an array that I don't understand. When I print it out somehow it has gotten into this form.

[list([0.5, 0.5, 0.2, 1])]

I've got to either force it into this form

[[0.5, 0.5, 0.2, 1]]

or find some way to subtract 0.5 from each element that works on both of these variants.

---

NEXT, I want to multiply each element times 2.

Here is code that produces an error.

TypeError: unsupported operand type(s) for -: 'list' and 'float'

import numpy as np
r = np.array(
          [
              [[.5,.5,2.,1.],0.,2.5]
          ]
        )
p = r[:,0]
print(p)            #output is [list([0.5, 0.5, 2.0, 1.0])]
r = (p - 1/2) * 2    #fail

Answer 1

import numpy as np

def flatten(l):
    if l == []:
        return l
    if isinstance(l[0], list):
        return flatten(l[0]) + flatten(l[1:])
    return l[:1] + flatten(l[1:])

inp = [[[.5,.5,2.,1.],0.,2.5]]
flat = flatten(inp)


r = np.array(flat)
p = r.copy()
print(p)
r = (p - 1/2) * 2

Just had to flatten your list, recursive

---

EDIT:

Following your comment

I've got r = np.array( [ [[.5,.5,2.,1.],0.,2.5] [[.5,.5,2.,1.],0.,2.5] ] ) I want to extract the first column and get the form [[.5,.5,2.,1.] [.5,.5,2.,1.] ]

just do

flat = inp[0]

and the rest is the same

Answer 2

Your problem is understanding exactly what a numpy array is. Check out some of the docs but essentially a numpy array is a specific data type that allows efficient vectorised operations over the dimensions of the array. So that means every element of the array needs to be of the same type AND the array must have pre-defined dimensions. A python list is a much more flexible container that can accept arbitrary objects into its elements but the downside of this is that you can't perform the efficient vectorised operations as you can in numpy (and as you wish to do).

So essentially you are asking a numpy array to contain the following:

• a list of floats: [.5,.5,2.,1.]
• a float: 0.
• a float: 2.5

These are not all the same types (one is a list and two are floats).

You need to make sure that these are the same types (AND exactly the same dimensions) otherwise numpy will not be able to create the correct typed array.

So the following will work:

a = np.array([.5,.5,2.,1.,0.,2.5])
a -= 0.5

Or if you need a 3 x 3 matrix then:

a = np.array([
        [.5, .5, 2.],
        [1., 0., 2.5],
        [0, 0, 0]
    ])
a -= 0.5

Notice in the above example how each element is a list with three floats in it. If you change one of those lists to contain 2 or 4 floats then you are breaking the idea that the numpy array must have a fixed dimensionality and it will no longer work.

Answer 3

Here's what works.

 R = np.matrix(
              [   #w   x   y  z     height    aspect-ratio
                  [.5,.5,2.,1.,     2.,        2.5]   
              ] 
            )
  P = R[:,0:4]    #get the first four columns  
  r = (P - 1/2)* 2