Np empty python что это

numpy.empty#

Return a new array of given shape and type, without initializing entries.

Parameters : shape int or tuple of int

Shape of the empty array, e.g., (2, 3) or 2 .

dtype data-type, optional

Desired output data-type for the array, e.g, numpy.int8 . Default is numpy.float64 .

order <‘C’, ‘F’>, optional, default: ‘C’

Whether to store multi-dimensional data in row-major (C-style) or column-major (Fortran-style) order in memory.

like array_like, optional

Reference object to allow the creation of arrays which are not NumPy arrays. If an array-like passed in as like supports the __array_function__ protocol, the result will be defined by it. In this case, it ensures the creation of an array object compatible with that passed in via this argument.

New in version 1.20.0.

Array of uninitialized (arbitrary) data of the given shape, dtype, and order. Object arrays will be initialized to None.

Return an empty array with shape and type of input.

Return a new array setting values to one.

Return a new array setting values to zero.

Return a new array of given shape filled with value.

empty , unlike zeros , does not set the array values to zero, and may therefore be marginally faster. On the other hand, it requires the user to manually set all the values in the array, and should be used with caution.

Common placeholders in numpy arrays

The underlying data block for numpy is the n-dimensional array. Often, the elements of an array are not known (especially in data science), and we need some kind of placeholders for the values in the arrays. Numpy is an indispensable library for anyone performing data manipulation or calculations. But some of the features of this powerful library may not be that straightforward for beginners. Here we take a look at the different placeholder functions that numpy offers and analyze them in-depth.

Creating an array in numpy

Before all else, let’s create an array in numpy that can be manipulated. Numpy offers many ways to create an array, including converting existing lists and tuples to arrays. Although not necessary, it is generally best practice to define the data type that you want in the ‘dtype’ argument. Numpy automatically extracts the datatype from the given data and upcasts them if required. That is, if you provide a mix of integers and floats, it converts the integers into floats too. The following is the simplest way to make a new numpy array from scratch:

The shape of a numpy array (sometimes referred to as their size) defines the number of rows and columns (and other dimensions) in a numpy array. As shown in the figures below, a 1-dimensional array has only one axis, and its shape is given by (n), where n is the number of elements in the axis. A 2-dimensional array has two axes, and the shape is provided by the form (m,n) where m denotes the number of rows and n denotes the number of columns. The extra dimension in a 3-dimensional array defines its depth and so on.

Now that we know how to create a simple array, we move on to placeholders.

Placeholders

Except when making tutorials (or giving examples), we seldom know what is in an array. Many instances of initiation of an array use some numbers as the placeholders for the real unknown values. It comes in play more often in data science (in my experience), where one has to initially randomly assign values (or sometimes zeros and ones) for weights or bias in a given numpy array that is later modified by the algorithm while training. Numpy offers about six types of placeholders that one can use while creating a new array. They span six functions and some additional functions that are discussed below.

np.zeros

As the name suggests, the np.zeros function fills the whole array with zeros. A simple example is given below:

The zeros function accepts shapes as the first parameter and dtype as an optional parameter. The dtype by default is float, and thus in the first example, all the zeros are floats.

np.ones

The np.ones function fills the whole array with ones. Here also, the default data type is float. Like the previous function, we provide the shape of the output array as the first argument to the function.

np.empty

Now that I think of it, all the functions are perfectly named in python. (My brain to me: That’s what happens in any language you dumbass.) So, the empty function effectively produces an empty array. As opposed to np.zeros, here we do not get a zero value array, but the placeholders are uninitialized. Thus, one has to enter the values manually later if one chooses to use this function. As the values cannot be blanks, the values are tiny numbers that are not recognized as entries for the array. The array values are not initialized; thus, it is marginally faster than other methods where the values are initialized. The first argument, as always, is the shape of the output array.

np.full

The np.full function structure is a bit different from the others until now. Along with the shape and datatype, it also takes another argument called ‘fill_value.’ It returns an array of the given shape filled with the fill_value. The fill_value needs to be a scalar (a simple number).

The like functions

Instead of providing the shape of the output array, one can provide a given array to the respective ‘like’ functions and obtain the results as before. The above four functions have corresponding ‘like’ functions named np.zeros_like, np.ones_like, np.empty_like, and np.full_like. The following example makes things clearer.

np.eye

Okay, the terminology is not that good at times, I guess. The np.eye function produces a diagonal matrix. It returns a 2-D array with 1’s on the diagonals, and 0’s everywhere else. Unlike the previous functions that take a tuple or list for shape, the np.eye function takes two individual parameters for rows and columns. It also takes a third argument called ‘k’ which denotes the diagonal that should be filled with ones. A value of 0 fills the main diagonal, a positive value fills the upper diagonal, and a negative value fills the lower diagonal. An example will make things clearer.

np.random.random

As mentioned earlier, there are times when we want certain randomness in the values initialized in an array. The np.random.random function serves the purpose. The purpose of this function is to return random values from a continuous uniform distribution in the range [0.0, 1.0), i.e., the values returned range from 0.0 to 1.0 (1.0 excluded), and all the values have an equal chance of being selected. We can use this function to return a single number or an array of a given shape by providing the shape of the array as an input parameter.

Conclusion

We have seen a lot of ways to introduce placeholders into arrays in numpy. The sheer number of different functions present tells us that using placeholders in numpy as a very critical task. I prefer using np.empty as it is just a bit faster, and then I can assign values accordingly. Another thing to note is that the np.eye function always returns a two-dimensional array. Which one did you like the most?

Before you go…

Connect with me on Instagram and Facebook.
If you liked this story, hit the clap button (you can clap up to 50 times with just one button!) and follow me for more such articles!

Share, recommend, and comment away! Engagement helps us communicate and be more human!

numpy.empty¶

Return a new array of given shape and type, without initializing entries.

shape : int or tuple of int

Shape of the empty array

dtype : data-type, optional

Desired output data-type.

Whether to store multi-dimensional data in row-major (C-style) or column-major (Fortran-style) order in memory.

out : ndarray

Array of uninitialized (arbitrary) data of the given shape, dtype, and order. Object arrays will be initialized to None.