# Read numpy array in Python

Numpy is a numerical python that deals with multidimensional arrays mostly used in storing multiple values. Python's core scientific computing package is called NumPy. This Python library provides multidimensional array objects, various derived objects (such as masked arrays and matrices), and several routines for quickly manipulating arrays. Even though we haven't covered the fundamentals, working with matrices is much simpler when NumPy is used (instead of nested lists).

Numbers are arranged in rows and columns in a matrix with two dimensions. Numpy can access multiple arrays with multiple dimensions. The scientific computing package NumPy supports a potent N-dimensional array object. Discrete Fourier transforms, elementary linear algebra, statistical operations, shape manipulation, sorting, selecting, I/O, random simulation, and many other operations are among them.

NumPy arrays and standard Python sequences are fundamentally different. The nd array object is at the center of the NumPy package. This includes homogeneous n-dimensional data type arrays of data, with many operations, performed quickly in compiled code.

- NumPy arrays are created with a fixed size, unlike Python lists. If the size of the nd array changes, the old array will be deleted and a new one created.
- NumPy arrays allow it to carry out intricate mathematical and other operations on large amounts of data.
- Unlike Python's built-in sequences, such operations are typically carried out more quickly and with less code.
- A NumPy array's elements must all be the same data type to share the same objects, allowing arrays with various element sizes.
- NumPy arrays are used in many Python-based scientific and mathematical packages. Before processing input, they convert it to NumPy arrays and frequently output NumPy arrays.

## Why is NumPy Fast?

When there is no explicit looping, indexing, etc., in the code, it is said to be vectorized. Of course, these operations are performed "behind the scenes" in C code that has been optimized and pre-compiled. There are many advantages to vectorized code, including:

- Code that is vectorized is shorter and simpler to read.
- Generally speaking, fewer lines of code equal fewer bugs.
- The code resembles standard mathematical notation more closely (making it easier, typically, to code mathematical constructs correctly)
- Vectorization makes code more "Pythonic," Without vectorization, our code would be filled with loop reads that are both time-consuming and inefficient.

## Why are NumPy Faster Than Lists?

Contrary to lists, NumPy arrays are stored in a single continuous location in memory, making it easy for processes to access and manipulate them. The locality of reference is used to describe this phenomenon in computer science. This is the primary factor that makes NumPy faster than lists. Additionally, it has been enhanced to support the newest CPU architectures.

## NumPy Installation?

NumPy is very simple to install if Python and PIP are already set up on a system.

Use this command to install Numpy

c:\users\name\pip install numpy

## Importing NumPy

Install NumPy and then import it by adding the import keyword to your applications:

Import numpy as np

NumPy is now imported and available for use:

```
Import numpy as np
X=np.array([1,2,3,4,5])
print(X)
```

**Output**

[1,2,3,4,5]

## Verifying the NumPy version

```
Import numpy as ar
print(ar.__version__)
```

## N-Dimensional array in Numpy (ndarray)

A list of elements of the same type, each indexed by a tuple of positive integers, is what Numpy refers to as an array. The form of the array is a tuple of numbers representing the array's size along each dimension, and the number of dimensions is referred to as the array's rank in Numpy.

**Nd array** is the name of an array class in Numpy. Square brackets are used to access elements in Numpy arrays, and nested Python Lists can be used to initialize the arrays.

The same data can be shared among different ndarrays, allowing changes made in one to be seen in another. This means that a ndarray can be a "view" to another ndarray, with the "base" ndarray handling the data it refers to. Additionally, ndarrays can be viewed into memory held by Python objects or strings that implement the interfaces for buffers and arrays.

**Example**

```
Import numpy as arr
x=arr.numpy([1,2,3][4,5,6])
print(x)#printing array x
print(type(x)) #printing type of x object
print(x.ndim) #printing array x dimensions
print(x.shape) #printing shape of array x
print(x.size)#printing size of array x
```

**Output**

```
[1,2,3] [4,5,6]
<class ‘numpy.ndarray’>
2
(2,3)
6
```

## Dimensions in Arrays

NumPy, a Python package that may be used for scientific and numerical applications, is the ideal tool for operations in linear algebra. The ndarray, a shortened name for an N-dimensional array, is the primary data structure in NumPy. Data in a ndarray is referred to as an array when using NumPy. It is a memory array with a fixed size that holds data of the same type, like integers or floating point numbers.

There are numerous additional qualities. The "dtype" attribute on an array can be used to access the data types that the array supports. To retrieve an array's dimensions, use the "shape" attribute, which provides a tuple listing each dimension's length. Making an array from data or fundamental Python data structures like the list using array() function is quick and simple quick and simple to make an array from data or fundamental Python data structures like a list using the array() function. A dimension is a level of array depth (nested arrays) in arrays.

## 0-D(0-Dimensional) Arrays

The components of an array are called 0-D arrays or Scalars. An array's values are all 0-D arrays. In zero dimensions, a numpy array is a scalar. It is inaccessible through indexing. A zero-dimensional array can be modified. Its dimensions are 0, and its shape is ().

**Example**

```
import numpy as np
a = np.array(1)
print("Printing the numpy array’s shape")
print(a.shape)
print("Printing the numpy array’s dimensions")
print(a.ndim)
```

**Output**

```
Printing the numpy array's shape
()
Printing a numpy array's dimensions
0
```

## 1-D(1-Dimensional) Arrays

One-dimensional Numpy arrays can be compared to lists where the elements are accessible through indexing. If you want, I can explain the array's shape. It would be the array's total number of elements. The length of each dimension of the array to be created is specified in an array or tuple that is passed as an argument to the function. The elements of an array are all the same datatype. Please see the code below to understand my viewpoint. In any dimensional array except 0-D, the array indexing starts from 0. Uni-dimensional or 1-D arrays are arrays that are made up entirely of 0-D arrays.

**Example**

```
import numpy as np
a = np.array([1, 2, 3, 4, 5])
print("Accessing the second element from the array ")
print(a[2])
print("Printing the shape of numpy array")
print(a.shape)
print("Printing the dimension of numpy array")
print(a.ndim)
```

**Output**

```
Accessing the array's second element
3
Printing a numpy array's shape
(5,)
Printing the numpy array's dimensions
1
```

## 2-D(2-Dimensional) Arrays

When working with a matrix, you might imagine getting results in either two-dimensional numpy arrays or three-dimensional numpy arrays, which can be distinguished based on the number of square brackets used. There are n axes in an array of n dimensions. Axis 0 denotes column-wise operation, whereas axis 1 denotes row-wise operation. The matrix's shape will depend on how many rows and columns there are. If you didn't understand the above sentences, don't worry. With the aid of the following code, I will explain these lines to you.

**Example**

```
import numpy as np
a = np.array([[1, 2, 3, 4, 5], [6,7,8,9,5]])
print(a)
print("Accessing the FIFTH element from the second row of the array ")
print(a[1][4])
print("Printing the shape of a numpy array in the form of rows and columns")
print(a.shape)
print("Printing the dimension of the numpy array")
print(a.ndim)
print("Please see the sum columns wise")
print(a.sum(axis=0))
print("Please see the sum row-wise")
print(a.sum(axis=1))
```

**Output**

```
[[1 2 3 4 5]
[6 7 8 9 5]]
Accessing the FIFTH element from the second row of the array
6
Printing the shape of a numpy array in the form of rows and columns
(2,5)
Printing the dimension of the numpy array
2
Please see the sum columns wise
[7,9,11,13,10]
Please see the sum row-wise
[15 35]
```

## 3-D(3-Dimensional) Arrays

I am confident that you have a good understanding of the two-dimensional code and that you have run it. Code is offered so that you can practice and better grasp the concepts. One can visualize the three-dimensional matrix using the three-square bracket, and the numpy array three-square bracket and the numpy array; oneone can visualize the three-dimensional matrix. Easy to do. The shape informs us of the number of 2D matrices and rows and columns for each. Running the code below simplifies this slightly complicated situation. To help you understand the concept more concretely, I advise you to run the code. Spend a little time running the code, please.

**Example**

```
import numpy as np
x=np.array([[[1,2,3],[4,5,6],[[1,2,3],[4,5,6]]])
1
print(arr)
```

**Output**

```
[[1 2 3]
[4 5 6]]
[[1 2 3]
[4 5 6]]]
```

## NumPy Array Indexing

NumPy array elements can be accessed by indexing. Indexing is a method of extracting a subset of values from an array. There is a distinction between the value and the location of the value in an array. The index of a value in an array represents the position of that value within the array.

### Accessing 1-D Arrays

**Example**

```
Import numpy as np
arr=np.array([4,5,2,8])
print(arr)
print(arr[3])
```

**Output**

```
[4,5,2,8]
8
```

The array's index (or location) of each value (or location) each value in the array is shown in the table below. The index for the value 4 is 0. We could also say that 4 is in array location 0. The index for value 5 is one, the index for value 2 is two, and the index for value 8 is three.

INDEX | VALUES |

0 | 4 |

1 | 5 |

2 | 2 |

3 | 8 |

Using a mechanism, any item in an array can be chosen at random based on its N-dimensional index. The number of indexes in each integer array corresponds to that dimension. When the index contains the same number of integer arrays as the dimensions of the target ndarray, the problem becomes straightforward.

### Accessing 2-D Arrays

Accessing elements from 2-D arrays requires comma-separated integers that represent the element's dimension and index.

Consider 2-D arrays to be tables with rows and columns, with the row representing the dimension and the index representing the column.

## Example

```
import numpy as np
arr=np.array([[1,2,3,4],[4,3,2,1]])
print(arr)
print(arr[0,2])
```

**Output**

```
[[1,2,3,4]
[4,3,2,1]]
3
```

By combining one slice (:) or ellipsis (...) with an index array, advanced and basic indexing can be combined. In the following example, the slice is used for the row, and the advanced index is used for the column. When the slice is used for both, the result is the same. However, advanced indexing causes a copy and may have a different memory layout.

### Accessing 3-D Arrays

NumPy is a Python library that includes multidimensional arrays and numerous functions for performing mathematical and logical operations on them. Accessing elements from 3-D arrays involves using comma-separated integers that represent the element's dimensions and index.. NumPy also includes functions for performing linear algebra operations and generating random numbers.

**Example**

```
Import numpy as np
Arr=np.array([[[1 2 3],[4 5 6],[10 11 12]]])
print(arr)
print(arr[0,1,1])
```

**Output**

```
[[[1 2 3]
[4 5 6]]
[7 8 9]
[10 11 12]]]
5
```

### Slicing

Slicing in Python refers to moving elements from one index to another. Instead of index, we pass slice: [start:end]. We can also specify the step as [start:end:]step.

If we do not pass the start, it is assumed to be 0.

If we do not pass the end, the array's length in that dimension is assumed.

If we do not complete a step, it is considered 1.

**Example**

```
Import numpy as np
arr=np.array([2,3,4,5,6])
print(arr)
print(arr[0:2])
```

**Output**

```
[2,3,4,5,6]
[2,3,4]
```

**Negative slicing**

To refer to an index from the end, use the minus operator:

**Example**

```
Import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr)
print(arr[-2:-1])
```

**Output**

```
[1,2,3,4,5,6,7]
6
```

### Numpy data types

Python includes a basic set of data types. In comparison to Python, NumPy supports a broader range of data types. The greater the variety of data types, the more functional NumPy becomes. The array elements' data type specification options expand. Everyone is associated with a data type object. This data type object provides information about the array's layout. There are five fundamental numerical types: Boolean, integers, unsigned integers (uint), floating point, and complex. Those with numbers in their names indicate the type's bit size. This should be considered when interacting with low-level code that addresses raw memory.

- Strings-Strings represent text data; the text is enclosed in quotation marks.
- Integer- It is a type of number used to represent an integer
- Float-float - a type of data used to represent a real number
- Boolean-It represents True or False.
- Complex- a symbol for complex numbers.
- M – datetime
- m – timedelta
- O - object
- S - string
- U - Unicode string

### 1) Integer

**Example**

```
Import numpy as np
arr = np.array([1, 2, 3, 4])
print(arr)
print(arr.dtype)
```

**Output**

```
[1,2,3,4]
Int64
```

### 2) String

**Example**

```
Import numpy as np
arr = np.array(['apple', 'banana's', 'cherry'])
print(arr.dtype)
```

**Output**

```
['apple','banana's,'cherry']
<u6
```