Voici un code simple qui fonctionne, mais pas comme je l'entend:

import random
R = random.randint(0,4)
G = random.randint(0,4)
B = random.randint(0,4)
for value in R,G,B: #debut boucle for
if value != 0:
value *= 64
value -= 1
print(value)

1. fin boucle for

print(R,G,B)

Les valeurs de "value" sont les bonnes, mais assigner une valeur à value lorsque celui-ci parcourt R n'assigne pas pour autant cette valeur à R.
Comment faire ce que j'essaie de faire?
Merci !

tu ne peux pas faire comme ca pour changer la valeur de variables dont le type est non mutable (int, float, tuple, str, ...)

import random
R = random.randint(0,4)
G = random.randint(0,4)
B = random.randint(0,4)
tab = (R,G,B)
for i in xrange(len(tab)): #debut boucle for
if tab[i] != 0:
tab[i] *= 64
tab[i] -= 1
print(tab[i])

1. fin boucle for

R,G,B = tab
print(R,G,B)

m'enfin ca m'a l'air bien complexe d'utiliser ce type de boucle pour au final juste trouver des valeurs entre 0 et 255. (mais peut etre que c'est necessaire dans ton cas d'avoir juste 64 valeurs possibles pour chaque composantes ?)
import random
R = random.randint(0,255)
G = random.randint(0,255)
B = random.randint(0,255)

Merci pour ta réponse.

On peut faire comme tu dis avec des valeurs aleatoires entre 0 et 255, mais le fait est que du coup, statistiquement, les couleurs ne seront en majorité pas "petantes" puisque même si une composante est proche de 255, les deux autres ont beaucoup de chances d'en être loin.
En restreignant à 4 valeurs possibles, on s'assure d'avoir plus de couleurs flashy (mais moins nombreuses).

Maintenant, je vais lire la difference entre xrange et range sur google^^

@SoueulsDotNet

ton second message ne fonctionne pas pour 2 raisons:
- R peut prendre des valeurs entre 0 et 256 COMPRIS. soit en tout 257 valeurs differents, donc R peut potentiellement sortir de son domaine de definition.
- si R se voit affecter une valeur soit inferieur a 60 soit suppérieur a 255-61 alors G et B peuvent a leur tout sortir de l'interval [0;255]

@Triple14 :
je ne connaissait pas cette méthode pour avoir des couleurs "pétantes", j'essairai la prochaines fois que je genererai des couleurs.
Sinon la difference entre range et xrange c'est que le premier génère une liste en mémoire, le second non. Donc c'est sencé aller plus vite, surtout si tu en a juste besoin pour d'un iterateur comme c'est le cas dans ma boucle.

sinon en une affreuse ligne tu peux faire tes trois couleurs d'un coup comme ceci :
r,g,b = (0 if a==-1 else a for a in (random.randint(0,4)*64-1 for i in xrange(3)))
Finalement ya pas que en C qu'on peut faire des choses moches

@SoueulsDotNet :
effectivement c'est bien de se prendre par la main mais si tu donne du code pour repondre a un probleme et que tu sais qu'il n'est pas complet, essaye au moins de prevenir, ya plein de gens qui passe sur les forums et qui ne font que copier sans comprendre. Ca a pas l'air d'etre le cas de OP mais on sait jamais.

"Y'a 256 valeurs possibles, de 0 a 255 donc mon code est bon."
Non desole ton code est faux. Et puisqu'il faut se prendre en main je te laisse aller lire la doc pour savoir pourquoi

Pas de dispute les amis

Sinon Soueuls je n'ai pas compris la différence statistique entre ce que tu propose et les randint(0,255).

Je veux augmenter la probabilité d'une couleur flashy. Pour faire simple disons que ce qu'on nomme flashy est une couleur dont une seule composante est 255 et les autres 0 (on prend ça pour simplifier, plein d'autres types de couleurs sont flashy evidemment).

Avec la méthode du (0,255), voici ce que ca donne:
P(flashy) = P(Rflashy)*P(Gpasflashy)*P(Bpasflashy) + P(Rpasflashy)*P(Gflashy)*P(Bpasflashy) + P(Rpasflashy)*P(Gpasflashy)*P(Bflashy) = 3*1/256*255/256*255/256 = 1.2% environ.

Avec ma méthode, comme une composante de la couleur ne prend de valeurs que parmi {0, 63, 126, 191, 255), la probabilité devient :
P(flashy) = 3*1/5*4/5*4/5 = 38.4%

Le tout étant de trouver le meilleur compromis entre nombre de couleurs différentes et probabilité de flashy, j'ai choisi cette méthode. Evidemment au lieu de faire le randint pour (0,4) au début, je peux faire nimporte quoi d'autre du type (0,N) et multiplier par 256/N au lieu de 64 comme je le fais.

Mais la meilleur méthode je pense, si on cherche pas la rapidité, serait de donner une distribution de probabilité définie sur le domaine [0,255] pour chaque composante et qui favorise les hautes composantes.

la doc de random.randint