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)