DESCRIPTION.

Retourne pseudo-aléatoirement une liste de valeurs présentes dans une collection fournie.

SYNTAXE.

LST_Valeurs = random.choices ( collection , relatif , cumulatif , quota )

LST_Valeurs = ⇨ variable qui recevra la list ( ) [ optionnel ]

random.choice ( ) ⇨ appel de la méthode [ OBLIGATOIRE ]

collection ⇨ objet collection [ OBLIGATOIRE ]

quota ⇨ nombre d'éléments dans le sous-ensemble [ optionnel ]

relatif ⇨ pondération relative des éléments [ optionnel ]

cumulatif ⇨ pondération cumulée des éléments [ optionnel ]

REMARQUES.

collection doit être un objet valide contenant une collection de valeurs, tel que list ( ), tuple ( ), range ( ) ... Si collection est vide Python lèvera une exception. collection n'est pas un argument nommé, il doit donc toujours être le premier argument fourni à la méthode random.choices ( ).

quota est un argument nommé de la forme k = quantite, où quantite doit être un int ( ). Si quantite n'est pas strictement positif, la méthode retournera une liste vide : [ ]. Comme la méthode effectue un tirage avec remise, quantite peut être supérieur au nombre d'éléments dans collection, c'est à dire à len ( collection ). Si quota est absent, la valeur par défaut, k = 1, sera retenue, et un seul élément sera retourné dans la liste.

relatif est un argument nommé de la forme weights = sequence, où sequence doit être un objet valide contenant une collection de valeurs de type int ( ) avec autant d'éléments que collection. Chaque éléments de sequence corresponds au poids de pondération de l'élément de collection au même index. Plus le poids de pondération d'un élément est élevé, plus cet élément à de chance d'être tiré. Par exemple avec random.choices ( [ "A" , "B" , "C" ] , weights = [ 3 , 7 , 4 ] ), le poids total de collection est de 3 + 7 + 4 = 14. Donc "A" a 3 chances sur 14 d’être tiré, "B" a 7 chances sur 14 d’être tiré, "C" a 4 chances sur 14 d’être tiré. En quelque sorte, on pourrait considérer que collection corresponds à [ "A" , "A" , "A" , "B" , "B" , "B" , "B" , "B" , "B" , "B" , "C" , "C" , "C" , "C" ]. Si sequence n'est pas exactement le même nombre d'éléments que collection, ou si tous ses éléments valent 0, Python lèvera une exception.

cumulatif est un argument nommé de la forme cum_weights = sequence, où sequence doit être un objet valide contenant une collection de valeurs de type int ( ) avec autant d'éléments que collection. Chaque éléments de sequence corresponds à la somme des poids de pondération des éléments de collection de [ 0 , index ]. Par exemple avec random.choices ( [ "A" , "B" , "C" ] , weights = [ 3 , 7 , 4 ] ), équivaut à random.choices ( [ "A" , "B" , "C" ] , cum_weights = [ 3 , 10 , 14 ] ) car 0 + 3 = 3, 3 + 7 = 10 et 10 + 4 = 14. Donc "A" a 3 chances sur 14 d’être tiré, "B" a 7 chances sur 14 d’être tiré, "C" a 4 chances sur 14 d’être tiré.Si sequence n'est pas exactement le même nombre d'éléments que collection, ou si tous ses élément valent 0, Python lèvera une exception.

L'appel de la méthode random.choice ( ) n'accepte qu'un seul des attributs relatif et cumulatif, si les deux sont fournis Python lèvera une exception. Si aucun n'est fournis, chaque élémentsv de collection à la même probabilité d'être tiré.

A noter que techniquement la méthode random.choice ( ) utilise toujours cumulatif, si c'est relatif qui est fourni, il est converti à la forme cumulatif avant l'exécution de la méthode, c'est pourquoi il est conseiller d'utiliser de préférence cumulatif pour libérer le processeur de la conversion.  

La méthode random.choices ( ) effectue un tirage avec remise, la valeur pigée n'est pas retirée de collection. Un élément de collection peut donc apparaitre plusieurs fois dans la liste retournée, surtout si k est élevé et que le poids de pondération d'un élément est fort par rapport aux autres.

Voir la méthode random.sample ( ) effectuer un tirage sans remise.

EXEMPLES.

import random

LST_Couleurs = [ "noir" , "rouge" , "vert" , "jaune" , "bleu" , "fushia" , "cyan" , "blanc" ]

print ( random.choices ( LST_Couleurs , k = 12 ) )

retourne, par exemple, ['blanc', 'noir', 'jaune', 'vert', 'cyan', 'jaune', 'cyan', 'rouge', 'jaune', 'jaune', 'jaune', 'noir']

print ( random.choices ( LST_Couleurs , weights = [ 3 , 2 , 1 , 9 , 2 , 4 , 7 , 9 ] , k = 12 ) )

retourne, par exemple, ['fushia', 'cyan', 'jaune', 'cyan', 'fushia', 'jaune', 'jaune', 'blanc', 'cyan', 'bleu', 'fushia', 'jaune']

print ( random.choices ( LST_Couleurs , cum_weights = [ 1 , 3 , 4 , 9 , 10 , 14 , 17 , 19 ] , k = 12 ) )

retourne, par exemple, ['rouge', 'jaune', 'blanc', 'rouge', 'cyan', 'rouge', 'cyan', 'cyan', 'fushia', 'fushia', 'noir', 'blanc']

La méthode random.choices ( ) permet aussi de simuler des tirages sans remise. Le petit script suivant mémorise les trois derniers éléments tirés et leur donne un poids de 0 pour éviter qu'ils soient de nouveau tirés au cours des 3 tirages suivants.

# --- Importation du module ---

import random

# --- Initialisation générale ---

LST_Sans_Retraits = [ ]

LST_Avec_Retraits = [ ]

LST_Retraits = [ None ] * 3

TPL_Teintes = ( "noir" , "rouge" , "bleu" , "vert" , "blanc" )

# --- Tirages des valeurs ---

for ktirage in range ( 10 ) :

kponderation = [ ]

# --- MaJ des valeurs de pondération des éléments ---

for kelement in TPL_Teintes :

kpoids = 0 if kelement in LST_Retraits else 1

kponderation.append ( kpoids )

# --- Tirages avec remise ---

LST_Sans_Retraits.append ( random.choices ( TPL_Teintes ) [ 0 ] )

# --- Tirages sans remise ---

kvaleur = random.choices ( TPL_Teintes , weights = kponderation ) [ 0 ]

LST_Avec_Retraits.append ( kvaleur )

del LST_Retraits [ 0 ] 

LST_Retraits.append ( kvaleur )

# --- Visualisation et comparaison des résultats ---

print ( LST_Sans_Retraits )

print ( LST_Avec_Retraits ) 

retourne, par exemple, 

['noir', 'rouge', 'rouge', 'vert', 'rouge', 'blanc', 'blanc', 'noir', 'vert', 'blanc'] 

['bleu', 'noir', 'blanc', 'rouge', 'bleu', 'vert', 'blanc', 'noir', 'bleu', 'vert']

Dans LST_Sans_Retraits les éléments aux index 2 et 6, ont la même valeur que l'élément qui le précède.

Dans LST_Avec_Retraits deux éléments qui se suivent ont toujours une valeur différente.

La méthode random.choices ( ) permet rendre plus cohérent certaines suites de tirages. Par exemple, quand un dès qui roule, la nouvelle face, au dessus, ne peut pas être : ni la face précédente, ni la face opposée à la précédente. Par exemple si la face précédente était 2, alors les faces 2 et 5 ne peuvent pas être la face suivante.

# --- Importation du module ---

import random

# --- Initialisation générale ---

LST_Suite = [ ]

TPL_Faces = ( 1 , 2 , 3 , 4 , 5 , 6 )

# --- Tirages des valeurs ---

for ktirage in range ( 25 ) :

# --- MaJ des valeurs de pondération des éléments ---

try :

if kvaleur in ( 1 , 6 ) : kponderation = ( 0 , 1 , 1 , 1 , 1 , 0 )

if kvaleur in ( 2 , 5 ) : kponderation = ( 1 , 0 , 1 , 1 , 0 , 1 )

if kvaleur in ( 3 , 4 ) : kponderation = ( 1 , 1 , 0 , 0 , 1 , 1 )

except :

kponderation = ( 1 , 1 , 1 , 1 , 1 , 1 )

# --- Nouvelle face ---

kvaleur = random.choices ( TPL_Faces , weights = kponderation ) [ 0 ]

LST_Suite.append ( kvaleur )

# --- Affichage de la suites des faces ---

print ( LST_Suite )

retourne, par exemple, [5, 6, 2, 4, 6, 4, 2, 4, 5, 1, 2, 6, 4, 1, 2, 6, 4, 5, 6, 2, 1, 3, 1, 2, 1]