**What is NumPy?**

## NumPy is a general-purpose array-processing package. It provides a high-performance multidimensional array object, and tools for working with these arrays.

It is the fundamental package for scientific computing with Python. It contains various features including these important ones:

- A powerful N-dimensional array object
- Sophisticated (broadcasting) functions
- Tools for integrating C/C++ and Fortran code
- Useful linear algebra, Fourier transform, and random number capabilities

**1. Arrays in NumPy:** NumPy’s main object is the homogeneous multidimensional array.

- It is a table of elements (usually numbers), all of the same type, indexed by a tuple of positive integers.
- In NumPy dimensions are called
*axes*. The number of axes is*rank*. - NumPy’s array class is called
**ndarray**. It is also known by the alias**array**.

**Example :**

[[ 1, 2, 3],

[ 4, 2, 5]]

Here,

rank = 2 (as it is 2-dimensional or it has 2 axes)

first dimension(axis) length = 2, second dimension has length = 3

overall shape can be expressed as: (2, 3)# Python program to demonstrate

# basic array characteristics

import numpy as np# Creating array object

arr = np.array( [[ 1, 2, 3],

[ 4, 2, 5]] )# Printing type of arr object

print("Array is of type: ", type(arr))# Printing array dimensions (axes)

print("No. of dimensions: ", arr.ndim)# Printing shape of array

print("Shape of array: ", arr.shape)# Printing size (total number of elements) of array

print("Size of array: ", arr.size)# Printing type of elements in array

print("Array stores elements of type: ", arr.dtype)

Output :

`Array is of type: `

No. of dimensions: 2

Shape of array: (2, 3)

Size of array: 6

Array stores elements of type: int64

**2. Array creation: **There are various ways to create arrays in NumPy.

- For example, you can create an array from a regular Python list or
**tuple**using the**array**function. The type of the resulting array is deduced from the type of the elements in the sequences. - Often, the elements of an array are originally unknown, but its size is known. Hence, NumPy offers several functions to create arrays with
**initial placeholder content**. These minimize the necessity of growing arrays, an expensive operation.**For example:**np.zeros, np.ones, np.full, np.empty, etc. - To create sequences of numbers, NumPy provides a function analogous to range that returns arrays instead of lists.
**arange:**returns evenly spaced values within a given interval.**step**size is specified.**linspace:**returns evenly spaced values within a given interval.**num**no. of elements are returned.**Reshaping array:**We can use**reshape**method to reshape an array. Consider an array with shape (a1, a2, a3, …, aN). We can reshape and convert it into another array with shape (b1, b2, b3, …, bM). The only required condition is:

a1 x a2 x a3 … x aN = b1 x b2 x b3 … x bM . (i.e original size of array remains unchanged.)**Flatten array:**We can use**flatten**method to get a copy of array collapsed into**one dimension**. It accepts*order*argument. Default value is ‘C’ (for row-major order). Use ‘F’ for column major order.

**Note:** Type of array can be explicitly defined while creating array.

# Python program to demonstrate

# array creation techniques

import numpy as np# Creating array from list with type float

a = np.array([[1, 2, 4], [5, 8, 7]], dtype = 'float')

print ("Array created using passed list:\n", a)# Creating array from tuple

b = np.array((1 , 3, 2))

print ("\nArray created using passed tuple:\n", b)# Creating a 3X4 array with all zeros

c = np.zeros((3, 4))

print ("\nAn array initialized with all zeros:\n", c)# Create a constant value array of complex type

d = np.full((3, 3), 6, dtype = 'complex')

print ("\nAn array initialized with all 6s."

"Array type is complex:\n", d)# Create an array with random values

e = np.random.random((2, 2))

print ("\nA random array:\n", e)# Create a sequence of integers

# from 0 to 30 with steps of 5

f = np.arange(0, 30, 5)

print ("\nA sequential array with steps of 5:\n", f)# Create a sequence of 10 values in range 0 to 5

g = np.linspace(0, 5, 10)

print ("\nA sequential array with 10 values between"

"0 and 5:\n", g)# Reshaping 3X4 array to 2X2X3 array

arr = np.array([[1, 2, 3, 4],

[5, 2, 4, 2],

[1, 2, 0, 1]])newarr = arr.reshape(2, 2, 3)print ("\nOriginal array:\n", arr)

print ("Reshaped array:\n", newarr)# Flatten array

arr = np.array([[1, 2, 3], [4, 5, 6]])

flarr = arr.flatten()print ("\nOriginal array:\n", arr)

print ("Fattened array:\n", flarr)

Output :

Array created using passed list:

[[ 1. 2. 4.]

[ 5. 8. 7.]]Array created using passed tuple:

[1 3 2]An array initialized with all zeros:

[[ 0. 0. 0. 0.]

[ 0. 0. 0. 0.]

[ 0. 0. 0. 0.]]An array initialized with all 6s. Array type is complex:

[[ 6.+0.j 6.+0.j 6.+0.j]

[ 6.+0.j 6.+0.j 6.+0.j]

[ 6.+0.j 6.+0.j 6.+0.j]]A random array:

[[ 0.46829566 0.67079389]

[ 0.09079849 0.95410464]]A sequential array with steps of 5:

[ 0 5 10 15 20 25]A sequential array with 10 values between 0 and 5:

[ 0. 0.55555556 1.11111111 1.66666667 2.22222222 2.77777778

3.33333333 3.88888889 4.44444444 5. ]Original array:

[[1 2 3 4]

[5 2 4 2]

[1 2 0 1]]

Reshaped array:

[[[1 2 3]

[4 5 2]] [[4 2 1]

[2 0 1]]]Original array:

[[1 2 3]

[4 5 6]]

Fattened array:

[1 2 3 4 5 6]

**3. Array Indexing:** Knowing the basics of array indexing is important for analysing and manipulating the array object. NumPy offers many ways to do array indexing.

**Slicing:**Just like lists in python, NumPy arrays can be sliced. As arrays can be multidimensional, you need to specify a slice for each dimension of the array.**Integer array indexing:**In this method, lists are passed for indexing for each dimension. One to one mapping of corresponding elements is done to construct a new arbitrary array.**Boolean array indexing:**This method is used when we want to pick elements from array which satisfy some condition.

# Python program to demonstrate

# indexing in numpy

import numpy as np# An exemplar array

arr = np.array([[-1, 2, 0, 4],

[4, -0.5, 6, 0],

[2.6, 0, 7, 8],

[3, -7, 4, 2.0]])# Slicing array

temp = arr[:2, ::2]

print ("Array with first 2 rows and alternate"

"columns(0 and 2):\n", temp)# Integer array indexing example

temp = arr[[0, 1, 2, 3], [3, 2, 1, 0]]

print ("\nElements at indices (0, 3), (1, 2), (2, 1),"

"(3, 0):\n", temp)# boolean array indexing example

cond = arr > 0 # cond is a boolean array

temp = arr[cond]

print ("\nElements greater than 0:\n", temp)

Output :

Array with first 2 rows and alternatecolumns(0 and 2):

[[-1. 0.]

[ 4. 6.]]Elements at indices (0, 3), (1, 2), (2, 1),(3, 0):

[ 4. 6. 0. 3.]Elements greater than 0:

[ 2. 4. 4. 6. 2.6 7. 8. 3. 4. 2. ]

# Dimensions in Arrays

A dimension in arrays is one level of array depth (nested arrays).

**nested array:** are arrays that have arrays as their elements.

# 0-D Arrays

0-D arrays, or Scalars, are the elements in an array. Each value in an array is a 0-D array.

# Example

Create a 0-D array with value 42

import numpy as np

arr = np.array(42)

print(arr)

# 1-D Arrays

An array that has 0-D arrays as its elements is called uni-dimensional or 1-D array.

These are the most common and basic arrays.

# Example

Create a 1-D array containing the values 1,2,3,4,5:

import numpy as np

arr = np.array([1, 2, 3, 4, 5])

print(arr)

# 2-D Arrays

An array that has 1-D arrays as its elements is called a 2-D array.

These are often used to represent matrix or 2nd order tensors.

NumPy has a whole sub module dedicated towards matrix operations called `numpy.mat`

# Example

Create a 2-D array containing two arrays with the values 1,2,3 and 4,5,6:

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])

print(arr)

**3-D arrays**

An array that has 2-D arrays (matrices) as its elements is called 3-D array.

These are often used to represent a 3rd order tensor.Example

# Example

Create a 3-D array with two 2-D arrays, both containing two arrays with the values 1,2,3 and 4,5,6:

import numpy as np

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])

print(arr)

**Limitations of NumPy**

Below are the points explain the Limitations of NumPy:

**Using “nan” in Numpy:**“Nan” stands for “not a number”. It was designed to address the problem of missing values. NumPy itself supports “nan” but lack of cross-platform support within Python makes it difficult for the user. That’s why we may face problems when comparing values within the Python interpreter.**Require a contiguous allocation of memory:**Insertion and deletion operations become costly as data is stored in contiguous memory locations as shifting it requires shifting.

# Installing NumPy

It’s time to get everything set up so you can start learning how to work with NumPy. There are a few different ways to do this, and you can’t go wrong by following the instructions on the NumPy website. But there are some extra details to be aware of that are outlined below.

You’ll also be installing Matplotlib. You’ll use it in one of the later examples to explore how other libraries make use of NumPy.

# Using Repl.it as an Online Editor

If you just want to get started with some examples, follow along with this tutorial, and start building some muscle memory with NumPy, then Repl.it is a great option for in-browser editing. You can sign up and fire up a Python environment in minutes. Along the left side, there’s a tab for packages. You can add as many as you want. For this NumPy tutorial, go with the current versions of NumPy and Matplotlib.

Here’s where you can find the packages in the interface:

Luckily, they allow you to just click and install.

# Installing NumPy With Anaconda

The Anaconda distribution is a suite of common Python data science tools bundled around a **package manager** that helps manage your virtual environments and project dependencies. It’s built around `conda`

, which is the actual package manager. This is the method recommended by the NumPy project, especially if you’re stepping into data science in Python without having already set up a complex development environment.

If you’ve already got a workflow you like that uses `pip`

, Pipenv, Poetry, or some other toolset, then it might be better not to add `conda`

to the mix. The `conda`

package repository is separate from PyPI, and `conda`

itself sets up a separate little island of packages on your machine, so managing paths and remembering which package lives where can be a nightmare.

Once you’ve got `conda`

installed, you can run the `install`

command for the libraries you’ll need:

`$ conda install numpy matplotlib`

This will install what you need for this NumPy tutorial, and you’ll be all set to go.

# Installing NumPy With `pip`

Although the NumPy project recommends using `conda`

if you’re starting fresh, there’s nothing wrong with managing your environment yourself and just using good old `pip`

, Pipenv, Poetry, or whatever other alternative to `pip`

is your favorite.

Here are the commands to get set up with `pip`

:

$ mkdir numpy-tutorial

$ cd numpy-tutorial

$ python3 -m venv .numpy-tutorial-venv

$ source .numpy-tutorial-venv/bin/activate(.numpy-tutorial-venv)

$ pip install numpy matplotlib

Collecting numpy

Downloading numpy-1.19.1-cp38-cp38-macosx_10_9_x86_64.whl (15.3 MB)

|████████████████████████████████| 15.3 MB 2.7 MB/s

Collecting matplotlib

Downloading matplotlib-3.3.0-1-cp38-cp38-macosx_10_9_x86_64.whl (11.4 MB)

|████████████████████████████████| 11.4 MB 16.8 MB/s

...