Summary  
This chapter covers generating random numbers and arrays using NumPy’s random module—specifically the rand function for floats from a uniform [0,1) distribution and randint for integers over a specified interval—while allowing you to specify array dimensions and value ranges.

General domain of usage  
Simulations (e.g., Monte Carlo methods)

It is often the case that we need to generate a random number or an array of random numbers. Luckily, **NumPy** has a module named `random` specifically for this purpose.

The two most commonly used functions of the `random` module are:
* `rand()`;
* `randint()`.

## rand()

The `numpy.random.rand()` function is used to generate either a random `float` number or an **array** of random floats from a uniform distribution over $$[0, 1)$$.

Square brackets $$[$$ or $$]$$ in interval notation indicate that the value is included, while parentheses $$($$ or $$)$$ indicate that the value is excluded. For example, $$[0, 1)$$ means the interval includes 0 but not 1. Don't confuse this **mathematical notation** with brackets used in code - they serve different purposes.

Note

Its only possible arguments are the **dimensions** of the array. If no argument is passed, `rand()` generates a random `float` number (**scalar**).

import numpy as np
# Generating a random number
random_number = np.random.rand()
print(random_number)
# Generating a random 1D array with 5 elements
random_array = np.random.rand(5)
print(random_array)
# Generating a random 2D array (matrix) of shape 4x3
random_matrix = np.random.rand(4, 3)
print(random_matrix)

Dimensions in the `rand()` function should be specified as **separate integer parameters**, not as a tuple of integers. For example, `rand(4, 3)` is correct, while `rand((4, 3))` is incorrect.

## randint()

The `numpy.random.randint` function is used to generate either a random **integer** or an **array of random integers** from a discrete uniform distribution within a specified interval.



Its three most important parameters are `low` (the only **required** parameter), `high`, and `size`. The interval is `[low, high)` (from `low` inclusive to `high` exclusive). However, if `high` is not specified, then the interval is `[0, low)`.


import numpy as np
# Generating a random integer from 0 to 3 exclusive
random_integer = np.random.randint(3)
print(random_integer)
# Generating a 1D array of random integers in [0, 5) with 4 elements
random_int_array = np.random.randint(5, size=4)
print(random_int_array)
# Generating a 1D array of random integers in [2, 5) with 4 elements
random_int_array_2 = np.random.randint(2, 5, size=4)
print(random_int_array_2)
# Generating a random 2D array of random integers in [1, 6) of shape 4x2
random_int_matrix = np.random.randint(1, 6, size=(4, 2))
print(random_int_matrix)

Unlike `rand()`, we specify the dimensions of the array via a single parameter `size`, passing either an **integer** or a **tuple of integers**.

import unittest
import importlib.util
import numpy as np


def _dynamic_test(test_case, condition, success_message, failure_message):
    """Codefinity-style test result 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):
        # Імпортуємо user_code
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        cls.m = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(cls.m)

    def test_random_floats_array(self):
        """1. random_floats_array — 1D масив з 4 випадкових float у [0, 1)"""
        ok = hasattr(self.m, "random_floats_array")
        arr = getattr(self.m, "random_floats_array", None)
        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.shape == (4,)
        dtype_ok = type_ok and np.issubdtype(arr.dtype, np.floating)
        range_ok = type_ok and np.all((arr >= 0) & (arr < 1))

        _dynamic_test(
            self,
            ok and type_ok and shape_ok and dtype_ok and range_ok,
            "random_floats_array created correctly",
            "random_floats_array incorrect or has wrong properties",
        )

    def test_random_floats_matrix(self):
        """2. random_floats_matrix — 2D масив 3x2 з випадкових float у [0, 1)"""
        ok = hasattr(self.m, "random_floats_matrix")
        arr = getattr(self.m, "random_floats_matrix", None)
        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.shape == (3, 2)
        dtype_ok = type_ok and np.issubdtype(arr.dtype, np.floating)
        range_ok = type_ok and np.all((arr >= 0) & (arr < 1))

        _dynamic_test(
            self,
            ok and type_ok and shape_ok and dtype_ok and range_ok,
            "random_floats_matrix created correctly",
            "random_floats_matrix incorrect or has wrong properties",
        )

    def test_random_integers_matrix(self):
        """3–5. random_integers_matrix — 2D масив 3x2 з int у [10, 21)"""
        ok = hasattr(self.m, "random_integers_matrix")
        arr = getattr(self.m, "random_integers_matrix", None)
        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.shape == (3, 2)
        dtype_ok = type_ok and np.issubdtype(arr.dtype, np.integer)
        range_ok = type_ok and np.all((arr >= 10) & (arr < 21))

        _dynamic_test(
            self,
            ok and type_ok and shape_ok and dtype_ok and range_ok,
            "random_integers_matrix created correctly",
            "random_integers_matrix incorrect or has wrong properties",
        )


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.

Random Arrays

rand()

randint()

Soluzione