Understanding NumPy Arrays: Homogeneous Multidimensional Data Structures.
-
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.).
-
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.
-
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).
- A 1-D array (e.g.,
Creating the NumPy array:
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:
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)
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:
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)
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:
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)
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).
Creating the array using numeric range series:-
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:
# Create an array with even numbers from 10 to 18
even_numbers = np.arange(start=10, stop=20, step=2)
print(even_numbers)
[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. π
Top comments (0)