NumPy Array in Python

What is a NumPy Array?

A NumPy array (also known as ndarray) is the core data structure of the NumPy library. It is a powerful, multi-dimensional, and homogeneous array designed for efficient numerical computations. Unlike Python lists, NumPy arrays offer optimized memory usage and fast mathematical operations, making them ideal for data science, machine learning, and scientific research.

Why Use NumPy Arrays Instead of Python Lists?

1. Performance: NumPy arrays are significantly faster than Python lists because they are implemented in C and use optimized memory management.
2. Memory Efficiency: NumPy arrays store data in contiguous memory locations, reducing the overhead of pointers used in Python lists.
3. Mathematical Operations: NumPy arrays support vectorized operations, eliminating the need for explicit loops in calculations.
4. Support for Multi-dimensional Data: Unlike lists, NumPy arrays seamlessly handle multi-dimensional datasets required for machine learning and deep learning.

Syntax of NumPy Array

To create a NumPy array, you need to import the NumPy library and use the numpy.array() function.

1
2
3
4
5
import numpy as np  # Importing the NumPy library

# Creating a simple 1D NumPy array
arr = np.array([1, 2, 3, 4, 5])
print(arr)  # Output: [1 2 3 4 5]

Explanation:

• import numpy as np: Imports the NumPy library and assigns it the alias np.
• np.array([1, 2, 3, 4, 5]): Creates a NumPy array from a Python list.
• print(arr): Displays the array elements.

Creating a NumPy ndarray Object

A NumPy ndarray is created using the numpy.array() function. Here’s an example:

1
2
3
4
5
import numpy as np  # Importing NumPy

# Creating a NumPy array
arr = np.array([10, 20, 30, 40, 50])
print(type(arr))  # Output: <class 'numpy.ndarray'>

Explanation:

• type(arr): Confirms that arr is a NumPy ndarray object.

Dimensions in NumPy Arrays

NumPy arrays can have multiple dimensions:

0-D NumPy Array (Scalar Array)

A 0-D array contains a single element:

1
2
3
4
5
import numpy as np  # Importing NumPy

# Creating a scalar (0-D) array
arr = np.array(42)
print(arr)  # Output: 42

1-D NumPy Array (Vector Array)

A 1-D array represents a simple list or a single row:

1
2
arr = np.array([1, 2, 3, 4, 5])
print(arr)  # Output: [1 2 3 4 5]

2-D NumPy Array (Matrix)

A 2-D array (matrix) consists of multiple rows and columns:

1
2
3
4
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)  # Output: 
# [[1 2 3]
#  [4 5 6]]

3-D NumPy Array (Tensor)

A 3-D array contains multiple 2-D arrays:

1
2
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print(arr)  # Output: 3-D Array structure

Anatomy of a NumPy Array

Understanding the structure of a NumPy array is crucial for efficient data manipulation.

1. Axis

Axis defines the direction along which operations are performed:

• Axis 0 (rows) runs vertically.
• Axis 1 (columns) runs horizontally.

2. Shape

The shape of a NumPy array refers to the number of elements along each dimension. The .shape attribute returns a tuple representing the array’s dimensions.

1
2
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr.shape)  # Output: (2, 3)

Explanation: The given array has 2 rows and 3 columns, so its shape is (2,3).

3. Rank

Rank represents the number of dimensions (axes) in the array. The .ndim attribute is used to check the rank.

1
print(arr.ndim)  # Output: 2

Explanation: Since arr is a 2D array, the output is 2, indicating two dimensions.

4. Data Type Objects (dtype)

NumPy arrays have a specific data type, which ensures efficient memory usage and type safety.

1
2
arr = np.array([1, 2, 3], dtype='int32')
print(arr.dtype)  # Output: int32

Explanation: The dtype parameter explicitly sets the data type to int32, ensuring memory efficiency.

Ways to Create a NumPy Array

1. Using numpy.array()

Creates an array from a Python list:

1
2
arr = np.array([1, 2, 3, 4, 5])
print(arr)  # Output: [1 2 3 4 5]

Explanation: Converts a simple Python list into a NumPy array.

2. Using numpy.fromiter()

Creates an array from an iterable object, such as a range.

1
2
3
iterable = range(5)
arr = np.fromiter(iterable, dtype=int)
print(arr)  # Output: [0 1 2 3 4]

Explanation: Uses fromiter() to construct an array from an iterable, maintaining type consistency.

3. Using numpy.arange()

Generates an array with a range of numbers:

1
2
arr = np.arange(1, 10, 2)  # Creates an array [1, 3, 5, 7, 9]
print(arr)

Explanation: arange() generates numbers from 1 to 10 (excluding 10) with a step of 2.

4. Using numpy.linspace()

Generates evenly spaced values between a start and an end value:

1
2
arr = np.linspace(0, 10, 5)  # Creates 5 evenly spaced numbers from 0 to 10
print(arr)

Explanation: linspace() generates 5 values between 0 and 10, inclusive.

5. Using numpy.empty()

Creates an array without initializing values:

1
2
arr = np.empty((2,3))  # Creates an uninitialized 2x3 array
print(arr)

Explanation: empty() creates an array of the specified shape, but the values are uninitialized (random garbage values).

6. Using numpy.ones()

Creates an array filled with ones:

1
2
arr = np.ones((3,3))  # Creates a 3x3 matrix filled with ones
print(arr)

Explanation: ones() creates an array with all elements set to 1.

7. Using numpy.zeros()

Creates an array filled with zeros:

1
2
arr = np.zeros((2,2))  # Creates a 2x2 matrix filled with zeros
print(arr)

Explanation: zeros() initializes all elements to 0.

Key Points

• NumPy arrays provide a more efficient alternative to Python lists.
• They support multiple dimensions and various methods for array creation.
• The shape of an array defines its structure.
• The rank tells the number of dimensions.
• Using predefined NumPy functions like arange(), linspace(), and fromiter() can make array creation faster and more optimized.

Do’s and Don’ts

Do’s:

• Use NumPy arrays for numerical computations instead of lists.
• Specify dtype explicitly when memory optimization is required.
• Utilize built-in NumPy functions for efficient operations.

Don’ts:

• Don’t use Python loops for element-wise operations; use NumPy’s vectorized operations.
• Don’t mix data types in NumPy arrays, as it affects performance.
• Don’t ignore broadcasting rules when working with different array shapes.

Conclusion

In this lesson, we covered the fundamental concepts of NumPy arrays, including:

• What NumPy arrays are and why they are useful.
• The syntax for creating NumPy arrays.
• Understanding dimensions (0-D, 1-D, 2-D, 3-D).
• The anatomy of a NumPy array (axis, shape, rank, dtype).
• Various methods to create NumPy arrays with explanations.