Summary  
This chapter explains how to convert multi-dimensional arrays into one-dimensional arrays using reshape(-1), ravel, and flatten methods, and highlights the difference between operations that return a view versus a copy of the original array.  

General domain of usage  
Numerical computing (e.g., data preprocessing for machine learning)

**Flattening** an array means converting it from a multi-dimensional array into a **1D array**, essentially unraveling its contents.

This operation is useful when you need to process the elements of an array **one by one** or when you want to make data more suitable for certain algorithms.

There are three possible options for flattening in **NumPy**:
* Using the `ndarray.reshape(-1)` method or the `numpy.reshape(array, -1)` function;
* Using the `ndarray.ravel()` method or the `numpy.ravel(array)` function;
* Using the `ndarray.flatten()` method.

## reshape(-1)

The `.reshape(-1)` method or the `reshape(array, -1)` function will return a **contiguous flattened array** with the same number of elements.

As we have already mentioned in the previous chapter, `-1` **automatically** calculates the size of the dimension based on the original array's size. Since we pass only a single integer for `shape`, a **1D array** with the same number of elements is returned.

import numpy as np
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
flattened_array = array_2d.reshape(-1)
print(f'Flatenned array: {flattened_array}')
# Changing the first element of flattened_array
flattened_array[0] = 10
print(f'Modified initial array:\n{array_2d}')

The `.reshape()` method or the respective function returns a **view** of the original array, so any changes made to the reshaped array will also affect the original array.

Using `flattened_array = np.reshape(array_2d, -1)` can be used instead of calling the method.

## ravel()

The `ndarray.ravel()` method or the `numpy.ravel(array)` function works the same as `reshape(-1)` and also returns a **view** of the original array:

import numpy as np
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
flattened_array = array_2d.ravel()
print(f'Flatenned array: {flattened_array}')
# Changing the first element of flattened_array
flattened_array[0] = 10
print(f'Modified initial array:\n{array_2d}')

`flattened_array = np.ravel(array_2d)` can be used instead of calling the method.

## ndarray.flatten()

In case you want a copy of the original array, not a view, you can use the `.flatten()` method:

import numpy as np
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
flattened_array = array_2d.flatten()
print(f'Flatenned array: {flattened_array}')
# Changing the first element of flattened_array
flattened_array[0] = 10
print(f'Initial array:\n{array_2d}')

You can always **copy** a view of an array to create a separate object and modify this copy without affecting the original array.

Note

import unittest
import importlib.util
import numpy as np
import io
from contextlib import redirect_stdout


def _dynamic_test(test_case, condition, success_message, failure_message):
    """Codefinity-style output formatting"""
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


class TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        # Початковий масив
        cls.exam_scores = np.array([
            [75, 82, 90],
            [92, 88, 78],
            [60, 70, 85]
        ])
        cls.flattened_expected = cls.exam_scores.flatten()

    def test_flatten_method(self):
        """1. flatten() used correctly"""
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)

        ok = hasattr(module, "exam_scores_flattened")
        arr = getattr(module, "exam_scores_flattened", None)
        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.ndim == 1
        val_ok = type_ok and np.array_equal(arr, self.flattened_expected) or arr[0] == 100

        _dynamic_test(
            self,
            ok and type_ok and shape_ok and val_ok,
            "exam_scores_flattened created correctly with flatten()",
            "exam_scores_flattened incorrect or not flattened properly",
        )

    def test_reshape_method(self):
        """2. reshape(-1) used correctly"""
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)

        ok = hasattr(module, "exam_scores_reshaped")
        arr = getattr(module, "exam_scores_reshaped", None)
        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.ndim == 1
        val_ok = type_ok and np.array_equal(arr, self.flattened_expected)

        _dynamic_test(
            self,
            ok and type_ok and shape_ok and val_ok,
            "exam_scores_reshaped created correctly with reshape(-1)",
            "exam_scores_reshaped incorrect or not flattened properly",
        )

    def test_ravel_method(self):
        """3. ravel() used correctly"""
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)

        ok = hasattr(module, "exam_scores_raveled")
        arr = getattr(module, "exam_scores_raveled", None)
        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.ndim == 1
        val_ok = type_ok and np.array_equal(arr, self.flattened_expected)

        _dynamic_test(
            self,
            ok and type_ok and shape_ok and val_ok,
            "exam_scores_raveled created correctly with ravel()",
            "exam_scores_raveled incorrect or not flattened properly",
        )

    def test_flatten_is_copy_and_modified(self):
        """4. Only flatten() result is modified and original array unchanged"""
        f = io.StringIO()
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        module = importlib.util.module_from_spec(spec)
        with redirect_stdout(f):
            spec.loader.exec_module(module)

        arr_flat = getattr(module, "exam_scores_flattened", None)
        arr_reshaped = getattr(module, "exam_scores_reshaped", None)
        arr_raveled = getattr(module, "exam_scores_raveled", None)
        arr_original = getattr(module, "exam_scores", None)

        # flatten() копія має бути змінена (перший елемент == 100)
        flatten_modified = isinstance(arr_flat, np.ndarray) and arr_flat[0] == 100
        # reshape() і ravel() не змінені
        reshaped_unchanged = isinstance(arr_reshaped, np.ndarray) and arr_reshaped[0] != 100
        raveled_unchanged = isinstance(arr_raveled, np.ndarray) and arr_raveled[0] != 100
        # оригінальний масив не змінено
        original_unchanged = isinstance(arr_original, np.ndarray) and arr_original[0, 0] == 75

        _dynamic_test(
            self,
            flatten_modified and reshaped_unchanged and raveled_unchanged and original_unchanged,
            "flatten() is copy and modified correctly without affecting original",
            "flatten() not modified correctly or original array affected",
        )


if __name__ == "__main__":
    unittest.main()


test_code.py

Develop essential skills for numerical computing using NumPy. Learn how to work with NumPy arrays, create and manipulate multidimensional data, apply indexing and slicing, perform vectorized operations, reshape arrays, use broadcasting, and apply basic linear algebra techniques. The course focuses on practical operations commonly used in data analysis tasks.

Flattening Arrays

reshape(-1)

ravel()

ndarray.flatten()

Lösung