Related Articles

# Python: Operations on Numpy Arrays

• Last Updated : 30 Jan, 2020

NumPy is a Python package which means ‘Numerical Python’. It is the library for logical computing, which contains a powerful n-dimensional array object, gives tools to integrate C, C++ and so on. It is likewise helpful in linear based math, arbitrary number capacity and so on. NumPy exhibits can likewise be utilized as an effective multi-dimensional compartment for generic data.

NumPy Array: Numpy array is a powerful N-dimensional array object which is in the form of rows and columns. We can initialize NumPy arrays from nested Python lists and access it elements. A Numpy array on a structural level is made up of a combination of:

• The Data pointer indicates the memory address of the first byte in the array.
• The Data type or dtype pointer describes the kind of elements that are contained within the array.
• The shape indicates the shape of the array.
• The strides are the number of bytes that should be skipped in memory to go to the next element.

#### Operations on Numpy Array

Arithmetic Operations:

 `# Python code to perform arithmetic``# operations on NumPy array`` ` ` ` `import` `numpy as np `` ` ` ` `# Initializing the array``arr1 ``=` `np.arange(``4``, dtype ``=` `np.float_).reshape(``2``, ``2``) `` ` `print``(``'First array:'``) ``print``(arr1)`` ` `print``(``'\nSecond array:'``) ``arr2 ``=` `np.array([``12``, ``12``]) ``print``(arr2)`` ` `print``(``'\nAdding the two arrays:'``) ``print``(np.add(arr1, arr2))`` ` `print``(``'\nSubtracting the two arrays:'``) ``print``(np.subtract(arr1, arr2))`` ` `print``(``'\nMultiplying the two arrays:'``)``print``(np.multiply(arr1, arr2))`` ` `print``(``'\nDividing the two arrays:'``)``print``(np.divide(arr1, arr2))`

Output:

```First array:
[[ 0.  1.]
[ 2.  3.]]

Second array:
[12 12]

[[ 12.  13.]
[ 14.  15.]]

Subtracting the two arrays:
[[-12. -11.]
[-10.  -9.]]

Multiplying the two arrays:
[[  0.  12.]
[ 24.  36.]]

Dividing the two arrays:
[[ 0.          0.08333333]
[ 0.16666667  0.25      ]]
```

numpy.reciprocol()

This function returns the reciprocal of argument, element-wise. For elements with absolute values larger than 1, the result is always 0 and for integer 0, overflow warning is issued.

Example:

 `# Python code to perform reciprocal operation``# on NumPy array``import` `numpy as np ``arr ``=` `np.array([``25``, ``1.33``, ``1``, ``1``, ``100``]) `` ` `print``(``'Our array is:'``)``print``(arr)`` ` `print``(``'\nAfter applying reciprocal function:'``) ``print``(np.reciprocal(arr))`` ` `arr2 ``=` `np.array([``25``], dtype ``=` `int``)``print``(``'\nThe second array is:'``)``print``(arr2)`` ` `print``(``'\nAfter applying reciprocal function:'``) ``print``(np.reciprocal(arr2))`

Output

```Our array is:
[  25.      1.33    1.      1.    100.  ]

After applying reciprocal function:
[ 0.04       0.7518797  1.         1.         0.01     ]

The second array is:


After applying reciprocal function:

```

numpy.power()

This function treats elements in the first input array as the base and returns it raised to the power of the corresponding element in the second input array.

 `# Python code to perform power operation``# on NumPy array`` ` ` ` `import` `numpy as np `` ` ` ` `arr ``=` `np.array([``5``, ``10``, ``15``]) `` ` `print``(``'First array is:'``) ``print``(arr)`` ` `print``(``'\nApplying power function:'``) ``print``(np.power(arr, ``2``))`` ` `print``(``'\nSecond array is:'``) ``arr1 ``=` `np.array([``1``, ``2``, ``3``]) ``print``(arr1)`` ` `print``(``'\nApplying power function again:'``) ``print``(np.power(arr, arr1))`

Output:

```First array is:
[ 5 10 15]

Applying power function:
[ 25 100 225]

Second array is:
[1 2 3]

Applying power function again:
[   5  100 3375]
```

numpy.mod()

This function returns the remainder of division of the corresponding elements in the input array. The function `numpy.remainder()` also produces the same result.

 `# Python code to perform mod function``# on NumPy array`` ` ` ` `import` `numpy as np `` ` ` ` `arr ``=` `np.array([``5``, ``15``, ``20``]) ``arr1 ``=` `np.array([``2``, ``5``, ``9``]) `` ` `print``(``'First array:'``) ``print``(arr) `` ` `print``(``'\nSecond array:'``) ``print``(arr1)`` ` `print``(``'\nApplying mod() function:'``) ``print``(np.mod(arr, arr1))`` ` `print``(``'\nApplying remainder() function:'``) ``print``(np.remainder(arr, arr1))`

Output:

```First array:
[ 5 15 20]

Second array:
[2 5 9]

Applying mod() function:
[1 0 2]

Applying remainder() function:
[1 0 2]
```

Attention geek! Strengthen your foundations with the Python Programming Foundation Course and learn the basics.

To begin with, your interview preparations Enhance your Data Structures concepts with the Python DS Course. And to begin with your Machine Learning Journey, join the Machine Learning – Basic Level Course

My Personal Notes arrow_drop_up