how to create an array of specified dimension of specific type initialized with same value in python?

Question

I wanna create some array in python of array of specified dimension of specific type initialized with same value. i can use numpy arrays of specific size but I am not sure how to initialize them with a specific value. Off course I don't want to use zeros() or ones()

Thanks a lot.

Answer 1

There are lots of ways to do this. The first one-liner that occurred to me is tile:

>>> numpy.tile(2, 25)
array([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
       2, 2, 2, 2, 2])

You can tile a value in any shape:

>>> numpy.tile(2, (5, 5))
array([[2, 2, 2, 2, 2],
       [2, 2, 2, 2, 2],
       [2, 2, 2, 2, 2],
       [2, 2, 2, 2, 2],
       [2, 2, 2, 2, 2]])

However, as a number of answers below indicate, this isn't the fastest method. It's designed for tiling arrays of any size, not just single values, so if you really just want to fill an array with a single value, then it's much faster to allocate the array first, and then use slice assignment:

>>> a = numpy.empty((5, 5), dtype=int)
>>> a[:] = 2
>>> a
array([[2, 2, 2, 2, 2],
       [2, 2, 2, 2, 2],
       [2, 2, 2, 2, 2],
       [2, 2, 2, 2, 2],
       [2, 2, 2, 2, 2]])

According to a few tests I did, there aren't any faster approaches. However, two of the approaches mentioned in answers below are equally fast: ndarray.fill and numpy.full.

These tests were all done in ipython, using Python 3.6.1 on a newish mac running OS 10.12.6. Definitions:

def fill_tile(value, shape):
    return numpy.tile(value, shape)

def fill_assign(value, shape, dtype):
    new = numpy.empty(shape, dtype=dtype)
    new[:] = value
    return new

def fill_fill(value, shape, dtype):
    new = numpy.empty(shape, dtype=dtype)
    new.fill(value)
    return new

def fill_full(value, shape, dtype):
    return numpy.full(shape, value, dtype=dtype)

def fill_plus(value, shape, dtype):
    new = numpy.zeros(shape, dtype=dtype)
    new += value
    return new

def fill_plus_oneline(value, shape, dtype):
    return numpy.zeros(shape, dtype=dtype) + value

for f in [fill_assign, fill_fill, fill_full, fill_plus, fill_plus_oneline]:
    assert (fill_tile(2, (500, 500)) == f(2, (500, 500), int)).all()

tile is indeed quite slow:

In [3]: %timeit fill_tile(2, (500, 500))
947 µs ± 10.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Slice assignment ties with ndarray.fill and numpy.full for first place:

In [4]: %timeit fill_assign(2, (500, 500), int)
102 µs ± 1.37 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [5]: %timeit fill_fill(2, (500, 500), int)
102 µs ± 1.99 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [6]: %timeit fill_full(2, (500, 500), int)
102 µs ± 1.47 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In-place broadcasted addition is only slightly slower:

In [7]: %timeit fill_plus(2, (500, 500), int)
179 µs ± 3.7 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

And non-in-place broadcasted addition is only slightly slower than that:

In [8]: %timeit fill_plus_oneline(2, (500, 500), int)
213 µs ± 4.74 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Answer 2

How about:

shape = (100,100)
val = 3.14
dt = np.float
a = np.empty(shape,dtype=dt)
a.fill(val)

This way you can set things and pass the parameters in. Also, in terms of timings

In [35]: %timeit a=np.empty(shape,dtype=dt); a.fill(val)
100000 loops, best of 3: 13 us per loop

In [36]: %timeit a=np.tile(val,shape)
10000 loops, best of 3: 102 us per loop

So using empty with fill seems significantly faster than tile.

Answer 3

As of NumPy 1.8, you can use numpy.full() to achieve this.

>>> import numpy as np
>>> np.full((3,4), 100, dtype = int)
array([[ 100,  100,  100,  100],
       [ 100,  100,  100,  100],
       [ 100,  100,  100,  100]])