In [8]: import numpy as np

In [9]: a = np.array([1,2,3,4,5])

In [10]: int("".join(map(str, a)))
Out[10]: 12345

Use .astype.

>>> a = numpy.array([1, 2, 3, 4], dtype=numpy.float64)
>>> a
array([ 1.,  2.,  3.,  4.])
>>> a.astype(numpy.int64)
array([1, 2, 3, 4])

See the documentation for more options.

It is quite trivial

(X=='y').astype(int)

Should do the trick. It simply converts your array to True or False according to your requirements and then astype will impose the required datatype. By default int will give you 1 for True and 0 for False.

In [24]: x=np.array([[0.04816103]])                                                                          
In [25]: x                                                                                                   
Out[25]: array([[0.04816103]])
In [26]: x.shape                                                                                             
Out[26]: (1, 1)
In [27]: x[0,0]                                                                                              
Out[27]: 0.04816103
In [28]: x[0][0]                                                                                             
Out[28]: 0.04816103
In [29]: x.squeeze()                                                                                         
Out[29]: array(0.04816103)
In [30]: _.shape                                                                                             
Out[30]: ()
In [34]: x.item()                                                                                            
Out[34]: 0.04816103

Welcome to Data Science! You're question needs a little more detail... there are many many ways to make an array into a single number. You should say a little more about what you mean by meaningful.

Here are a few examples, using your example array, which may seem outrageously simple, but do indeed form the basis to many of the techniques used in modern research:

In [1]: import numpy as np

In [2]: x = np.array([[129, 155, 191], [123, 150, 185], [120, 149, 183]], dtype=np.float32)

In [3]: x
Out[3]: 
array([[129., 155., 191.],
       [123., 150., 185.],
       [120., 149., 183.]], dtype=float32)

Now here are a few (randomly selected) ways to create a single number from your array:

In [4]: np.mean(x)    # the mean / average
Out[4]: 153.88889

In [5]: np.sum(x)    # the sum
Out[5]: 1385.0

In [6]: np.std(x)    # the standard deviation
Out[6]: 25.722641

In [7]: np.linalg.norm(x)    # the Frobius norm - a distance measure
Out[7]: 468.07156

In [8]: np.max(x)
Out[8]: 191.0

These might seem stupidly simple, but if we were to treat your array as a single block from a larger image-array, then these might represent pooling-layers that are used to down-sample arrays as they are passed through a neural network. Just have a look at the available pooling layers within the Keras library.

Which method you might want to use will heavily depend on your use case, your dataset and your model.

numpy.astype returns a copy of the array. It does not manipulate your array in-place. So you have to assign the value to a variable:

Y = Y.astype(int)

Make a sample array

In [206]: x=np.array([1e9, 2e10, 1e6])
In [207]: x
Out[207]: array([  1.00000000e+09,   2.00000000e+10,   1.00000000e+06])

We can convert to ints - except notice that the largest one is too large the default int32

In [208]: x.astype(int)
Out[208]: array([ 1000000000, -2147483648,     1000000])

In [212]: x.astype(np.int64)
Out[212]: array([ 1000000000, 20000000000,     1000000], dtype=int64)

Writing a csv with the default format (float) (this is the default format regardless of the array dtype):

In [213]: np.savetxt('text.txt',x)
In [214]: cat text.txt
1.000000000000000000e+09
2.000000000000000000e+10
1.000000000000000000e+06

We can specify a format:

In [215]: np.savetxt('text.txt',x, fmt='%d')
In [216]: cat text.txt
1000000000
20000000000
1000000

Potentially there are 3 issues:

• integer v float in the array itself, it's dtype
• display or print of the array
• writing the array to a csv file

Solution 1 (faster)

integer = int("".join([str(x) for x in arr]))

Solution 2 (slower)

integer = np.sum(np.array([(10**exp) * elem for (elem, exp) in zip(arr, reversed(range(len(arr))))]))

Background (Digging Deeper)

I just measured, the solution with string casting and joining and int casting is about 5 times faster on random numbers with 30 digits.

The rest of this background info is just for fun. :-)

Why is int() so much faster...

Using int() is very fast because the function in cpython sourcecode corresponds to Modules/main.c's pymain_str_to_int() which uses the C-Function strtol under the hood.

But I still want to be faster...

So basically you could become faster if you would build a module in C for python similar to this:

int fast_arraytoint( const char * arr, int * result )
{
    long val = 0;
    while( *arr ) {
        val = val*10 + (*arr++);
    }
    if (val > INT_MAX) {
        return -1;
    }

    *result = (int)val;
    return 0;
}

To dig even deeper one must figure out how python handles big integers, the ones that have a value higher than INT_MAX and integrate the C-Module so it could be handled for all types of python's ints.

numpy.ndarray.tolist will do it:

a.tolist()

If your data is a pandas series you can call their tolist wrapper with the same result.