Numpy Array Object
Tags: numpy, python, array, data
Published: 2024-05-15 05:00:45

Understanding NumPy Arrays: Homogeneous Multidimensional Data Structures.

1. **Multidimensional Homogeneous Array**:
   - A NumPy array is a fundamental object that represents a multidimensional, homogeneous data structure.
   - "Homogeneous" means that all elements in the array have the same data type (e.g., all integers, all floats, etc.).

2. **Comparison with Python Lists**:
   - Unlike Python lists, which can contain elements of different types, a NumPy array enforces a consistent data type for all its elements.

3. **Dimensions and Axes**:
   - The dimension of a NumPy array refers to the number of axes it has.
   - For example:
     - A 1-D array (e.g., `[1, 2, 3]`) behaves like a single axis with three elements. Its length is 3.
     - A 2-D array (e.g., `[[1.0, 2.0, 3.0], [4.0, 6.0, 7.0]]`) has two axes:
       - The first axis (axis=0) has a length of 2 (i.e., two rows).
       - The second axis (axis=1) has a length of 3 (i.e., three columns).

## <u>Creating the NumPy array:</u>
In NumPy, we create N-D arrays using the array() function by passing Python lists or tuples.

Here is the example for 1-D array:

```python
import numpy as np

# Using a tuple to create a 1D NumPy array
array_from_tuple = np.array((1, 2, 3, 4, 5))

# Using a list to create a 1D NumPy array
array_from_list = np.array([6, 7, 8, 9, 10])

print("Array from tuple:", array_from_tuple)
print("Array from list:", array_from_list)
```

```python
Output:
Array from tuple: [1 2 3 4 5]
Array from list: [ 6  7  8  9 10]
```
In NumPy, we can explicitly specify the data types of an array using the dtype option in the array() function.
Here is the example:

```python
import numpy as np

# Using a tuple to create a 1D NumPy array
array_from_tuple = np.array((1, 2, 3, 4, 5), dtype=float)

# Using a list to create a 1D NumPy array
array_from_list = np.array([6, 7, 8, 9, 10],dtype=complex)

print("Array from tuple:", array_from_tuple)
print("Array from list:", array_from_list)
```

```python
Output:
Array from tuple: [1. 2. 3. 4. 5.]
Array from list: [ 6.+0.j  7.+0.j  8.+0.j  9.+0.j 10.+0.j]
```

> I will try to post a separate article on various types of datatypes in NumPy in the upcoming posts.

The array() function in NumPy transforms sequences (such as [1, 2, 3, 4, 5] and (2, 3, 4, 5)) into 1-D arrays. To create a 2-D array, we need to pass sequences of sequences, and for a 3-D array, we use sequences of sequences of sequences and so on.
Here is the following example of 2-D array creation using the array() function:

```python
import numpy as np

# Create a 2-D array with specific values
my_array = np.array([(10, 20, 30), (40, 50, 60)])

print(my_array)
```

```python
Output:
[[10 20 30]
 [40 50 60]
]
```
In this code snippet, passing a list of two tuples to the array() function results in a 2-D array, where the first dimension has a length of two(ie.,Rows) and the second, a length of three(ie.,Columns).

## <u>Creating the array using numeric range series:-</u>
NumPy provides the `arange` function, which allows for the creation of an array by specifying a numeric range. This function requires three arguments: `start`, `stop`, and `step`, enabling the construction of an array with the desired sequence of numbers.
Let’s see the following example:

```python
# Create an array with even numbers from 10 to 18
even_numbers = np.arange(start=10, stop=20, step=2)

print(even_numbers)
```

```python
[10 12 14 16 18]
```
Remember, the stop value is not included in the array, and the step defines the difference between each number in the sequence. You can also use non-integer steps, such as 0.5, to create arrays with decimal numbers.

In summary, NumPy arrays provide efficient and flexible ways to work with multi-dimensional data, ensuring consistent data types across elements. 🚀