Basics of NumPy Arrays
NumPy stands for Numerical Python. It is a Python library used for
working with an array. In Python, we use the list for the array but it’s slow
to process. NumPy array is a powerful N-dimensional array object and is
used in linear algebra, Fourier transform, and random number capabilities.
It provides an array object much faster than traditional Python lists.
Types of Array:
1. One Dimensional Array
2. Multi-Dimensional Array
One Dimensional Array:
A one-dimensional array is a type of linear array.
One Dimensional Array
Example:
# importing numpy module
import numpy as np
# creating list
list = [1, 2, 3, 4]
# creating numpy array
sample_array = np.array(list)
print("List in python : ", list)
print("Numpy Array in python :", sample_array)
List in python : [1, 2, 3, 4]
Numpy Array in python : [1 2 3 4]
1
Check data type for list and array:
print(type(list_1))
print(type(sample_array))
<class 'list'>
<class 'numpy.ndarray'>
Multi-Dimensional Array:
Data in multidimensional arrays are stored in tabular form.
Two Dimensional Array
# importing numpy module
import numpy as np
# creating list
list_1 = [1, 2, 3, 4]
list_2 = [5, 6, 7, 8]
list_3 = [9, 10, 11, 12]
# creating numpy array
sample_array = np.array([list_1, list_2, list_3])
print("Numpy multi dimensional array in python\n",
sample_array)
Output
Numpy multi dimensional array in python
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
NumPy Creating Arrays
2
NumPy is used to work with arrays. The array object in
NumPy is called ndarray.
We can create a NumPy ndarray object by using
the array() function.
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr)
print(type(arr))
[1 2 3 4 5]
<class 'numpy.ndarray'>
To create an ndarray, we can pass a list, tuple or any array-
like object into the array() method, and it will be converted
into an ndarray:
Example
Use a tuple to create a NumPy array:
import numpy as np
arr = np.array((1, 2, 3, 4, 5))
print(arr)
[1 2 3 4 5]
Dimensions in Arrays
A dimension in arrays is one level of array depth (nested
arrays).
3
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)
[1 2 3 4 5]
4
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)
[[1 2 3]
[4 5 6]]
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
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]],
5
[[1, 2, 3], [4, 5, 6]]])
print(arr)
[[[1 2 3]
[4 5 6]]
[[1 2 3]
[4 5 6]]]
Check Number of Dimensions?
NumPy Arrays provides the ndim attribute that returns an
integer that tells us how many dimensions the array
have.
Example
Check how many dimensions the arrays have:
import numpy as np
a = np.array(42)
b = np.array([1, 2, 3, 4, 5])
c = np.array([[1, 2, 3], [4, 5, 6]])
d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3],
[4, 5, 6]]])
print(a.ndim)
print(b.ndim)
print(c.ndim)
print(d.ndim)
0
1
2
3
6
Higher Dimensional Arrays
An array can have any number of dimensions.
When the array is created, you can define the number of
dimensions by using the ndmin argument.
Example
Create an array with 5 dimensions and verify that it has 5
dimensions:
import numpy as np
arr = np.array([1, 2, 3, 4], ndmin=5)
print(arr)
print('number of dimensions :', arr.ndim)
[[[[[1 2 3 4]]]]]
number of dimensions : 5
NumPy Array Indexing
Access Array Elements
Array indexing is the same as accessing an array element.
You can access an array element by referring to its index
number.
The indexes in NumPy arrays start with 0, meaning that the
first element has index 0, and the second has index 1 etc.
Example
Get the first element from the following array:
7
import numpy as np
arr = np.array([1, 2, 3, 4])
print(arr[0])
1
Example
Get the second element from the following array.
import numpy as np
arr = np.array([1, 2, 3, 4])
print(arr[1])
Example
Get third and fourth elements from the following array and
add them.
import numpy as np
arr = np.array([1, 2, 3, 4])
print(arr[2] + arr[3])
Access 2-D Arrays
To access elements from 2-D arrays we can use comma
separated integers representing the dimension and the
index of the element.
Think of 2-D arrays like a table with rows and columns,
where the dimension represents the row and the index
represents the column.
8
Example
Access the element on the first row, second column:
import numpy as np
arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])
print('2nd element on 1st row: ', arr[0, 1])
2nd element on 1st dim: 2
Example
Access the element on the 2nd row, 5th column:
import numpy as np
arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])
print('5th element on 2nd row: ', arr[1, 4])
5th element on 2nd dim: 10
Access 3-D Arrays
To access elements from 3-D arrays we can use comma
separated integers representing the dimensions and the
index of the element.
Example
Access the third element of the second array of the first array:
import numpy as np
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9],
[10, 11, 12]]])
print(arr[0, 1, 2])
9
Example Explained
arr[0, 1, 2] prints the value 6.
And this is why:
The first number represents the first dimension,
which contains two arrays:
[[1, 2, 3], [4, 5, 6]]
and:
[[7, 8, 9], [10, 11, 12]]
Since we selected 0, we are left with the first array:
[[1, 2, 3], [4, 5, 6]]
The second number represents the second dimension,
which also contains two arrays:
[1, 2, 3]
and:
[4, 5, 6]
Since we selected 1, we are left with the second
array:
[4, 5, 6]
The third number represents the third dimension,
which contains three values:
4
5
6
Since we selected 2, we end up with the third value:
6
Negative Indexing
Use negative indexing to access an array from the end.
10
Example
Print the last element from the 2nd dim:
import numpy as np
arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])
print('Last element from 2nd dim: ', arr[1, -1])
Last element from 2nd dim: 10
NumPy Array Slicing
Slicing arrays
Slicing in python means taking elements from one given
index to another given index.
We pass slice instead of index like this: [start:end].
We can also define the step, like this: [start:end:step].
If we don't pass start its considered 0
If we don't pass end its considered length of array in that
dimension
If we don't pass step its considered 1
Example
Slice elements from index 1 to index 5 from the following array:
import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[1:5])
[2 3 4 5]
11
Example
Slice elements from index 4 to the end of the array:
import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[4:])
[5 6 7]
Example
Slice elements from the beginning to index 4 (not included):
import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[:4])
[1 2 3 4]
Negative Slicing
Use the minus operator to refer to an index from the end:
Example
Slice from the index 3 from the end to index 1 from the end:
import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[-3:-1])
[5 6]
STEP
Use the step value to determine the step of the slicing:
12
Example
Return every other element from index 1 to index 5:
import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[1:5:2])
[2 4]
Example
Return every other element from the entire array:
import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[::2])
[1 3 5 7]
Slicing 2-D Arrays
Example
From the second element, slice elements from index 1 to
index 4 (not included):
import numpy as np
arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print(arr[1, 1:4])
[7 8 9]
Example
From both elements, return index 2:
import numpy as np
arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
13
print(arr[0:2, 2])
[3 8]
Example
From both elements, slice index 1 to index 4 (not included),
this will return a 2-D array:
import numpy as np
arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print(arr[0:2, 1:4])
[[2 3 4]
[7 8 9]]
numpy.swapaxes() function | Python
numpy.swapaxes() function interchange two axes of an array.
Syntax : numpy.swapaxes(arr, axis1, axis2)
Parameters :
arr : [array_like] input array.
axis1 : [int] First axis.
axis2 : [int] Second axis.
Return : [ndarray] In earlier NumPy versions, a view of arr is returned
only if the order of the axes is changed, otherwise the input array is
returned. For NumPy >= 1.10.0, if arr is an ndarray, then a view of arr is
returned; otherwise a new array is created.
# Python program explaining
# numpy.swapaxes() function
# importing numpy as np
import numpy as np
14
arr = np.array([[2, 4, 6]])
gfg = np.swapaxes(arr, 0, 1)
print (gfg)
Output :
[[2]
[4]
[6]]
Code #2 :
# Python program explaining
# numpy.swapaxes() function
# importing numpy as np
import numpy as np
arr = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]])
gfg = np.swapaxes(arr, 0, 2)
print (gfg)
Output :
[[[0 4]
[2 6]]
[[1 5]
[3 7]]]
Python | Numpy numpy.transpose()
With the help of Numpy numpy.transpose(), We can perform the simple
function of transpose within one line by using numpy.transpose() method
of Numpy. It can transpose the 2-D arrays on the other hand it has no
effect on 1-D arrays. This method transpose the 2-D numpy array.
Parameters:
axes : [None, tuple of ints, or n ints] If anyone wants to pass the
parameter then you can but it’s not all required. But if you want than
remember only pass (0, 1) or (1, 0). Like we have array of shape (2, 3) to
change it (3, 2) you should pass (1, 0) where 1 as 3 and 0 as 2.
Returns: ndarray
15
Example #1 :
In this example we can see that it’s really easy to transpose an array with
just one line.
# importing python module named numpy
import numpy as np
# making a 3x3 array
gfg = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# before transpose
print(gfg, end ='\n\n')
# after transpose
print(gfg.transpose())
Output:
[[1 2 3]
[4 5 6]
[7 8 9]]
[[1 4 7]
[2 5 8]
[3 6 9]]
16
Example #2 :
In this example we demonstrate the use of tuples in numpy.transpose().
# importing python module named numpy
import numpy as np
# making a 3x3 array
gfg = np.array([[1, 2],[4, 5],[7, 8]])
# before transpose
print(gfg, end ='\n\n')
# after transpose
print(gfg.transpose(1, 0))
Output:
[[1 2]
[4 5]
[7 8]]
[[1 4 7]
[2 5 8]]
Method 2: Using Numpy ndarray.T object.
# importing python module named numpy
import numpy as np
# making a 3x3 array
gfg = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
17
# before transpose
print(gfg, end ='\n\n')
# after transpose
print(gfg.T)
Output
[[1 2 3]
[4 5 6]
[7 8 9]]
[[1 4 7]
[2 5 8]
[3 6 9]]
18
