La fonction rd.randint permet de choisir un nombre uniformément au hasard dans une liste prédéterminée.

On considère deux entiers relatifs $a$ et $b$ tels que $a<b$.

• rd.randint(b) renvoie un nombre choisi au hasard dans $\{ 0,1,\dots,b-1 \}$ (si $b \geqslant 1$), c’est-à-dire une simulation d’une variable aléatoire de loi uniforme sur $\left[\kern-0.15em\left[ {0 , b-1} \right]\kern-0.15em\right]$.
• rd.randint(a,b) renvoie un nombre choisi au hasard dans $\{ a,a+1,\dots,b-1 \}$, c’est-à-dire une simulation d’une variable aléatoire de loi uniforme sur $\left[\kern-0.15em\left[ {a , b-1} \right]\kern-0.15em\right]$.

On peut également choisir plusieurs nombres simultanément et indépendamment les uns des autres.

On considère des entiers naturels non nuls $n$ et $p$.

• rd.randint(a,b,n) renvoie un vecteur de longueur $n$ dont les $n$ coefficients sont des simulations de variables aléatoires indépendantes et toutes de même loi uniforme sur $\left[\kern-0.15em\left[ {a , b-1} \right]\kern-0.15em\right]$.
• rd.randint(a,b,[n,p]) renvoie une matrice de $\mathcal{M}_{n,p}(\mathbb{R})$ dont les coefficients sont des simulations de $np$ variables aléatoires indépendantes et toutes de même loi uniforme sur $\left[\kern-0.15em\left[ {a , b-1} \right]\kern-0.15em\right]$.

La fonction rd.random permet de choisir un nombre uniformément au hasard dans $[0,1 ]$ ; autrement dit rd.random peut simuler une variable aléatoire de loi uniforme sur $[ 0,1 ]$.

Ainsi, pour simuler la réalisation d’un événement $E$ de probabilité $p$, on pourra utiliser par exemple comparer une valeur prise par rd.random() avec p et considérer que l’événement $E$ est réalisé si rd.random()<p et ne l’est pas sinon.

On peut également choisir plusieurs nombres simultanément et indépendamment les uns des autres.

On considère des entiers naturels non nuls $n$ et $p$.

• rd.random(n) renvoie un vecteur de longueur $n$ dont les $n$ coefficients sont des simulations de variables aléatoires indépendantes et toutes de même loi uniforme sur $[ 0,1 ]$.
• rd.random([n,p]) renvoie une matrice de $\mathcal{M}_{n,p}(\mathbb{R})$ dont les coefficients sont des simulations de $np$ variables aléatoires indépendantes et toutes de même loi uniforme sur $[0,1]$.

Soit $n,a,b$ des entiers naturel non nuls et $p$ un élément de $]0,1[$.

• rd.binomial(n,p) renvoie une simulation d’une variable aléatoire suivant la loi binomiale $\mathcal{B}(n,p)$.
• rd.binomial(n,p,a) renvoie un vecteur de longueur $a$ dont les coefficients représentent une simulation de $a$ variables aléatoires indépendantes et suivant toutes la loi binomiale $\mathcal{B}(n,p)$.
• rd.binomial(n,p,[a,b]) renvoie une matrice de $\mathcal{M}_{a,b}(\mathbb{R})$ dont les coefficients représentent une simulation de $ab$ variables aléatoires indépendantes et suivant toutes la loi binomiale $\mathcal{B}(n,p)$.

Soit $n,m$ des entiers naturel non nuls et $p$ un élément de $]0,1[$.

• rd.geometric(p) renvoie une simulation d’une variable aléatoire suivant la loi géométrique $\mathcal{G}(p)$.
• rd.geometric(p,n) renvoie un vecteur de longueur $n$ dont les coefficients représentent une simulation de $n$ variables aléatoires indépendantes et suivant toutes la loi géométrique $\mathcal{G}(p)$.
• rd.geometric(p,[n,m]) renvoie une matrice de $\mathcal{M}_{n,m}(\mathbb{R})$ dont les coefficients représentent une simulation de $nm$ variables aléatoires indépendantes et suivant toutes la loi géométrique $\mathcal{G}(p)$.

Soit $n,m$ des entiers naturel non nuls et $L$ un réel strictement positif.

• rd.poisson(L) renvoie une simulation d’une variable aléatoire suivant la loi de Poisson $\mathcal{P}(L)$.
• rd.poisson(L,n) renvoie un vecteur de longueur $n$ dont les coefficients représentent une simulation de $n$ variables aléatoires indépendantes et suivant toutes la loi de Poisson $\mathcal{P}(L)$.
• rd.poisson(L,[n,m]) renvoie une matrice de $\mathcal{M}_{n,m}(\mathbb{R})$ dont les coefficients représentent une simulation de $nm$ variables aléatoires indépendantes et suivant toutes la loi de Poisson $\mathcal{P}(L)$.

Soit $r,b,n$ des entiers naturels non nuls.

On dispose d’une urne contenant $r+b+n$ boules, dont $r$ sont rouges, $b$ sont bleues et $n$ sont noires. Pour simuler le tirage d’une boule au hasard dans cette urne avec Python, on peut utiliser la fonction suivante :

import numpy.random as rd
def Tirage(r,b,n):
    T=rd.randint(r+b+n)
    if T<r:
        return 'Rouge'
    elif T<r+b:
        return 'Bleue'
    else:
        return 'Noire'

À l’appel de cette fonction, le programme choisit un nombre au hasard dans $\{ 0,1,\dots,r+b+n \}$ et on considère que :

• les boules portant un numéro compris entre $1$ et $r-1$ sont les boules rouges,
• les boules portant un numéro compris entre $r$ et $r+b-1$ sont les boules bleues,
• les boules portant un numéro compris entre $r+b$ et $r+b+n-1$ sont les boules noires.

Soit $r,b,n$ des éléments de $]0,1[$ tels que $r+b+n = 1$.

On dispose d’une urne contenant des boules, dont une proportion $r$ de rouges, $b$ de bleues et $n$ de noires. Pour simuler le tirage d’une boule au hasard dans cette urne avec Python, on peut utiliser la fonction suivante :

import numpy.random as rd
def Tirage(r,b,n):
    T=rd.random()
    if T<r:
        return 'Rouge'
    elif T<r+b:
        return 'Bleue'
    else:
        return 'Noire'

À l’appel de cette fonction, le programme choisit un nombre au hasard dans $[0,1]$ et on considère que :

• les nombres de l’ensemble $[0,r [$ correspondent aux boules rouges,
• les nombres de l’ensemble $[r,r+b [$ correspondent aux boules bleues,
• les nombres de l’ensemble $[r+b,1 ]$ correspondent aux boules noires.

En effet, quand on choisit un nombre uniformément au hasard dans $[0,1]$, la probabilité que ce nombre appartienne à un intervalle $[a,b]$ (ou $]a,b]$, $[a,b[$, $]a,b [$) inclus dans $[0,1]$ est égale à la longueur $b-a$ de cet intervalle.

Soit $p$ un réel appartenant à $]0,1[$. Pour simuler le lancer d’une pièce donnant pile avec probabilité $p$ et face avec probabilité $1-p$, on peut utiliser la fonction Python suivante :

import numpy.random as rd
def Lancer(p):
    if rd.random()<p:
        return 'Pile'
    else:
        return 'Face'

Soit $p$ un réel appartenant à $]0,1[$ et $n$ un entier naturel non nul. On effectue une suite de $n$ lancers d’une pièce donnant pile avec probabilité $p$ et face avec probabilité $1-p$ et on note $X$ la variable aléatoire égale au nombre de piles obtenus.

Pour modéliser cette expérience et renvoyer la valeur prise par $X$ avec Python, deux possibilités s’offrent à nous.

On peut d’une part utiliser le modèle et simuler la suite de $n$ lancers de pièce à l’aide d’une boucle for, en ajoutant 1 à la variable X à chaque fois que l’on obtient pile (ce que l’on peut simuler avec rd.random()<p conformément au point précédent) :

import numpy.random as rd
def Simul(n,p):
    X=0
    for k in range(n):
        if rd.random()<p:
            X=X+1
    return X

On peut d’autre part remarquer que la variable aléatoire $X$ suit la loi binomiale $\mathcal{B}(n,p)$ et par conséquent proposer la fonction suivante :

import numpy.random as rd
def Simul(n,p):
    return rd.binomial(n,p)

Soit $p$ un réel appartenant à $]0,1[$. On effectue une suite de lancers d’une pièce donnant pile avec probabilité $p$ et on note $X$ la variable aléatoire égale au rang d’apparition du premier pile.

Pour modéliser cette expérience et renvoyer la valeur prise par $X$ avec Python, deux possibilités s’offrent à nous.

On peut d’une part utiliser le modèle et simuler la suite de lancers de pièce jusqu’à l’obtention d’un pile à l’aide d’une boucle while, en ajoutant 1 à la variable X à chaque fois que l’on obtient pile (ce que l’on peut simuler avec rd.random()<p conformément au point précédent) :

import numpy.random as rd
def Simul(p):
    X=1
    while rd.random()<p:
        X=X+1
    return X

On peut d’autre part remarquer que la variable aléatoire $X$ suit la loi géométrique $\mathcal{G}(p)$ et par conséquent proposer la fonction suivante :

import numpy.random as rd
def Simul(p):
    return rd.geometric(p)