Discussion :

[melwin]

Bonsoir,

je récupère des valeurs et je souhaite calculer leur fréquence relative.

Pour cela je dois incrémenter la fréquence d'une valeur chaque fois qu'elle apparait. C'est à dire incrémenter le compteur de chaque valeur.

A la fin, je divise la fréquence de chaque valeur par le nombre d'itération pour obtenir la fréquence relative.

Comment incrémenter les fréquences de chaque valeurs et ensuite afficher :

Valeur a : fréquence relative de a
Valeur b : fréquence relative de b
...

[melwin]

Voilà ou j'en suis

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
while i < nbPas :
    while val < 34 :
        val = tirage (val)              # tirage aléatoire qui increment val
        print ("val = ", val)
        liste.append(val)               # on ajoute la valeur dans une liste
        i += 1
    print ("val = ", val)
    liste.append(val)                   # a partir de 34 on ajoute la valeur 34
    i += 1    
 
incremente = {}
for l in liste:
    incremente [l] = incremente.get (l, 0) + 1      # frequence d'utilisation de chaque valeur
 
frequence = list(incremente.items())        # conversion en liste
frequence.sort()                            # trie par ordre alphabétique
print (frequence)

Test avec 10 pas:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Entrez le nombre de pas à effectuer : 10
val =  3
val =  6
val =  8
val =  9
val =  10
val =  11
val =  13
val =  16
val =  21
val =  27
val =  32
val =  34
val =  34
[(1, 1), (3, 1), (6, 1), (8, 1), (9, 1), (10, 1), (11, 1), (13, 1), (16, 1), (21, 1), (27, 1), (32, 1), (34, 2)]

[melwin]

J'ai avancé un peu, si vous avez une proposition plus propre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
while i < nbPas :
    while val < 34 :
        val = tirage (val)              # tirage aléatoire qui increment val
        print ("val = ", val)
        liste.append(val)               # on ajoute la valeur dans une liste
        i += 1
    print ("val = ", val)
    liste.append(val)                   # a partir de 34 on ajoute la valeur 34
    i += 1    
 
incremente = {}
for l in liste:
    incremente [l] = incremente.get (l, 0) + 1      # frequence d'utilisation de chaque valeur
print (incremente)
 
for k in incremente.keys():                 # on liste la séquence des clès
    j = incremente[k]/nbPas                 # on calcile la fréquence relative de chque
    print (" la fréquence relative de", k, "est : ", j)

Ce qui me donne comme résultat:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Entrez le nombre de pas à effectuer : 10
val =  6
val =  8
val =  13
val =  17
val =  23
val =  29
val =  30
val =  34
val =  34
{1: 1, 34: 2, 6: 1, 8: 1, 13: 1, 17: 1, 23: 1, 29: 1, 30: 1}
 la fréquence relative de 1 est :  0.1
 la fréquence relative de 34 est :  0.2
 la fréquence relative de 6 est :  0.1
 la fréquence relative de 8 est :  0.1
 la fréquence relative de 13 est :  0.1
 la fréquence relative de 17 est :  0.1
 la fréquence relative de 23 est :  0.1
 la fréquence relative de 29 est :  0.1
 la fréquence relative de 30 est :  0.1

Je sais trier mon dictionnaire en passant pas une liste de tuple mais ensuite je ne sais pas comment faire pour les fréquences relatives.

Là j'ai les fréquences mais pas dans l'ordre alphabétique des clés du dictionnaire.

[alexdevl]

Bonjour,
Voici un exemple en utilisant la class Counter (python 2.7),
Pour info le while en python est souvent remplacé par "for i in range(n)"
j'ai pas trop compris la condition supérieur à 34

Alex

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
!/usr/bin/env python
# -*- coding: utf-8 -*-
import random
import collections
 
valeurs=collections.Counter()
f_relatives=collections.Counter()
n_tirages=10
 
for t in range(n_tirages):
    val=random.randrange(1,20)
    print val
    valeurs[val]+=1
    f_relatives[val]=valeurs[val]*100.0/n_tirages
 
print valeurs.most_common()
print f_relatives.most_common()

et si on ne veut calculer les f relatives qu'après la boucle principale :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import random
import collections
 
valeurs=collections.Counter()
n_tirages=10
for t in range(n_tirages):
    val=random.randrange(1,20)
    print val
    valeurs[val]+=1
print valeurs.most_common()
 
f_relatives_apres=collections.Counter()
for val in valeurs.most_common():
    key=val[0]
    f_relatives_apres[key]=valeurs[key]*100.0/n_tirages
print f_relatives_apres.most_common()

[melwin]

Bonjour,
Voici un exemple en utilisant la class Counter (python 2.7),
Pour info le while en python est souvent remplacé par "for i in range(n)"
j'ai pas trop compris la condition supérieur à 34

Alex

C'est parce que c'est un petit jeu de l'oie et que ça s'arrête à la case 34.

[melwin]

Donc voilà mon programme, si quelqu'un a mieux à proposer pour la dernière partie. J'aurais aimé trier par fréquence ou pas case.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#############################################################################
# Importation de fonctions externes :
 
from random import randrange
from collections import Counter
 
 
#############################################################################
# Définition locale de fonction
 
def jetde (case):
    case += randrange (1, 7)            # Ajout aléatoire 1d6
    if case > 34 :
        case = 34                       # On s'arrête sur la dernière case
    return case
 
 
def obstacle (case):                    # Cases avec échelle ou flèche
    change = {2:31, 4:12, 8:2, 9:23,    # N° de case -> nouvelle case
              10:4, 13:27, 15:29, 18:25, 
              25:6, 28:16, 30:6, 32:19}      
 
    ret = [case]                        # On retient le n° de la case
    while case in change:               # Tant que la case est spéciale
        case = change[case]             # On va à la nouvelle case
        ret.append(case)                # On ajoute la nouvelle case
    return ret                          # On retourne toutes les cases parcourues
 
 
#############################################################################
# Corps principal du programme
 
nombre = input ("Entrez le nombre de pas à effectuer : ")
nbPas = int(nombre)                     # Conversion charactère en entier
 
case = 1                                # On démarre à la case 1
print("Case = ", case)
liste = [1]                             # Création de liste des cases parcourues
 
i = 1
while i < nbPas :
    while case < 34:
        case = jetde(case)              # Case après jet du dé
        for c in obstacle (case):       # Case(s) après passage obstacle
            print("Case = ", c)         # Affichage de la case en cours
            liste.append(c)              # Ajout de la case dans la liste
            i += 1
 
        case = c                        # Dernière case atteinte
    liste.append(case)
    i += 1
 
freq = Counter (liste)                  # 
for j in freq.keys():
    relat = freq [j]/nbPas              # Calcul des fréquences relatives
    print("La fréquence relative de la case", j, "est de :", relat)

[dividee]

J'aurais aimé trier par fréquence ou pas case.

Il suffit de remplacer la ligne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for j in freq.keys():

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for j in sorted(freq.keys()):

pour trier par case.

Ou bien par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for j in sorted(freq.keys(), key=lambda k: -freq[q])

pour trier par ordre décroissant de fréquence.

[alexdevl]

Bonsoir,
On peut utiliser une méthode de la classe counter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for j in freq.most_common():

[melwin]

Il suffit de remplacer la ligne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for j in freq.keys():

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for j in sorted(freq.keys()):

pour trier par case.

Ou bien par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for j in sorted(freq.keys(), key=lambda k: -freq[q])

pour trier par ordre décroissant de fréquence.

Le trie par casse me va très bien. Merci beaucoup pour votre aide. J'ai l'impression de progresser.

J'ai chopé des automatisme, plus de problème d'indentation. Je commence à me sentir de plus en plus à l'aise avec les listes, dictionnaire, manipulation de fichiers et ceci grâce à vous tous.

Et comme ça ne coûte rien de le dire et que ça fait plaisir. Merci à tous...