Python-将元组中的数组转换为普通数组

Question

I have a signal where I want to find the average height of the values. This is done by finding the zero crossings and calculating the max and min between each zero crossing, then averaging these values.

My problem occurs when I want to use np.where() to find where the signal is crossing zero. When I use np.where() I get the result in a tuple, but I want it in an array where I can count the amount of times zero is crossed.

I am new to Python and coming from Matlab it is a bit confusing with all the different classes. As you can see, I get an error because nu = len(zero_u) gives 1 as a result, because the whole array is written in a tuple as one element.

Any ideas how to go around this?

The code looks like this:

import numpy as np


def averageheight(f):

    rms = np.std(f)

    f = f + (rms * 10**-6)

    # Find zero crossing

    fsign = np.sign(f)
    fdiff = np.diff(fsign)

    zero_u = np.asarray(np.where(fdiff > 0)) + 1
    zero_d = np.asarray(np.where(fdiff < 0)) + 1

    nu = len(zero_u)
    nd = len(zero_d)
    value_max = np.zeros((nu, 1))
    value_min = np.zeros((nu, 1))
    imaxvec = np.zeros((nu, 1))
    iminvec = np.zeros((nu, 1))

    if (nu > 2) and (nd > 2):

        if zero_u[0] > zero_d[0]:
            zero_d[0] = []

        nu = len(zero_u)
        nd = len(zero_d)
        ncross = np.fmin(nu, nd)

        # Find Maxima:
        for ic in range(0, ncross - 1):
            up = int(zero_u[ic])
            down = int(zero_d[ic])
            fvec = f[up:down]
            value_max[ic] = np.amax(fvec)
            index_max = value_max.argmax()
            imaxvec[ic] = up + index_max - 1

        # Find Minima:
        for ic in range(0, ncross - 2):
            down = int(zero_d[ic])
            up = int(zero_u[ic+1])
            fvec = f[down:up]
            value_min[ic] = np.amin(fvec)
            index_min = value_min.argmin()
            iminvec[ic] = down + index_min - 1

        # Remove spurious values, bumps and zero_d
        thr = rms/3

        maxfind = np.where(value_max < thr)

        for i in range(0, len(maxfind)):
            imaxfind = np.where(value_max == maxfind[i])
            imaxvec[imaxfind] = 0
            value_max[imaxfind] = 0

        minfind = np.where(value_min > -thr)

        for j in range(0, len(minfind)):
            iminfind = np.where(value_min == minfind[j])
            value_min[iminfind] = 0
            iminvec[iminfind] = 0

        # Find Average Height

        avh = np.mean(value_max) - np.mean(value_min)

    else:
        avh = 0

    return avh

Answer 1

np.where , and np.nonzero even more so, clearly explains that it returns a tuple, with one array for each dimension of the condition array:

In [71]: arr = np.random.randint(-5,5,10)
In [72]: arr
Out[72]: array([ 3,  4,  2, -3, -1,  0, -5,  4,  2, -3])
In [73]: arr.shape
Out[73]: (10,)
In [74]: np.where(arr>=0)
Out[74]: (array([0, 1, 2, 5, 7, 8]),)
In [75]: arr[_]
Out[75]: array([3, 4, 2, 0, 4, 2])

That Out[74] tuple can be used directly as an index.

You can also extract the array from the tuple:

In [76]: np.where(arr>=0)[0]
Out[76]: array([0, 1, 2, 5, 7, 8])

That, I think is a better choice than the np.asarray(np.where(...))

This convention for where becomes clearer when we use it on a 2d array

In [77]: arr2 = arr.reshape(2,5)
In [78]: np.where(arr2>=0)
Out[78]: (array([0, 0, 0, 1, 1, 1]), array([0, 1, 2, 0, 2, 3]))
In [79]: arr2[_]
Out[79]: array([3, 4, 2, 0, 4, 2])

Again we are indexing with a tuple. arr2[1,3] is really arr2[(1,3)] . The values in [] indexing brackets are actually passed to the indexing function as a tuple of values.

np.argwhere applies transpose to the result of where , producing an array:

In [80]: np.transpose(np.where(arr2>=0))
Out[80]: 
array([[0, 0],
       [0, 1],
       [0, 2],
       [1, 0],
       [1, 2],
       [1, 3]])

That's the same indexing arrays, but arranged in a 2d column matrix.

If you need the count of where without the actual values, a slightly faster function is

In [81]: np.count_nonzero(arr>=0)
Out[81]: 6

In fact np.nonzero uses the count to first determine the size of the arrays that it will return.