Summary  
This chapter explains how to use NumPy’s random module to generate arrays of random floats with `rand()` and random integers with `randint()`, specifying dimensions and value ranges.  

General domain of usage  
Simulations

Det er ofte nødvendig å generere et tilfeldig tall eller et array med tilfeldige tall. Heldigvis har **NumPy** et modul kalt `random` spesielt for dette formålet.

Watch this video explanation to deepen your understanding of generating random arrays with NumPy. You'll see practical demonstrations of using the `rand()` and `randint()` functions, learn how to specify array dimensions, and discover common use cases for random number generation in data analysis and scientific computing. This video will reinforce the key concepts and help you confidently apply random arrays in your own Python projects.

De to mest brukte funksjonene i `random`-modulen er:
* `rand()`;
* `randint()`.

## rand()

Funksjonen `numpy.random.rand()` brukes til å generere enten et tilfeldig `float`-tall eller et **array** av tilfeldige flyttall fra en uniform fordeling over $$[0, 1)$$.

Firkantede parenteser $$[$$ eller $$]$$ i intervallnotasjon indikerer at verdien er inkludert, mens parenteser $$($$ eller $$)$$ indikerer at verdien er ekskludert. For eksempel betyr $$[0, 1)$$ at intervallet inkluderer 0, men ikke 1. Ikke forveksle denne **matematiske notasjonen** med parenteser brukt i kode – de har ulike formål.

Merk

De eneste mulige argumentene er **dimensjonene** til arrayet. Hvis ingen argumenter gis, genererer `rand()` et tilfeldig `float`-tall (**skalar**).

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)

Dimensjoner i `rand()`-funksjonen skal angis som **separate heltallsparametere**, ikke som en tuple med heltall. For eksempel er `rand(4, 3)` korrekt, mens `rand((4, 3))` er feil.

## randint()

Funksjonen `numpy.random.randint` brukes til å generere enten et tilfeldig **heltall** eller et **array av tilfeldige heltall** fra en diskret uniform fordeling innenfor et spesifisert intervall.



De tre viktigste parameterne er `low` (den eneste **påkrevde** parameteren), `high` og `size`. Intervallet er `[low, high)` (fra og med `low` til, men ikke med, `high`). Hvis `high` ikke er angitt, er intervallet `[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)

I motsetning til `rand()`, angir vi dimensjonene til arrayet via én enkelt parameter `size`, hvor vi oppgir enten et **heltall** eller en **tuple av heltall**.

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

Lås opp det fulle potensialet til Pythons mest essensielle bibliotek for numerisk databehandling, NumPy. Dette omfattende kurset er utformet for å ta deg fra et nybegynnernivå til avansert ferdighet i NumPy. Enten du er dataforsker, ingeniør, forsker eller utvikler, er det avgjørende å mestre NumPy for effektiv datamanipulering, vitenskapelig databehandling og maskinlæring.

Utforsk bruksområdene til NumPy og forstå hvorfor det er et av de mest populære bibliotekene for numerisk databehandling. Lær de ulike metodene for å opprette og initialisere matriser for å håndtere ulike databehov effektivt.

Utforsk hvordan du får tilgang til spesifikke elementer og delmengder i NumPy-arrays ved hjelp av indeksnotasjon. Lær å bruke betinget indeksering for å filtrere data og håndtere manglende verdier effektivt.

NumPy tilbyr mange innebygde funksjoner for å utføre vanlige array-operasjoner. Lær hvordan du kan bruke disse verktøyene til å transformere, aggregere og analysere data effektivt uten å skrive repeterende kode.

Lær hvordan du utfører matematiske operasjoner effektivt på NumPy-arrays. Bruk disse operasjonene for å løse virkelige problemer og få en dypere forståelse av hvordan vektoriserte beregninger akselererer numerisk analyse.

Tilfeldige Matriser

rand()

randint()

Løsning