Discussion :

[bootinette]

Bonjour,

J'apprends Python depuis peu et je suis coincée sur un problème de classement d'équipes, je détaille un peu plus:
j'ai un fichier texte qui ressemble à:
"2000
Monaco
Lyon
.
.
.
2001
Lyon
Marseille
.
.
."
Ce qui veut dire que pour l'an 2000 Monaco est arrivé premier etc jusqu'à 20 équipes et ça jusqu'à aujourd'hui, j'ai pas de souci pour afficher le podium de chaque année ou celui qui a le plus gagné au cours des dix dernières années.

Mon problème est le suivant je voudrais donner des points à chaque équipe chaque année du le premier a 20 points le deuxieme à 19 points.. et en demandant une équipe on pourait avoir son nombre de points depuis 10 ans.

Dans mon idée à chaque fois que le programme rencontre une année il commence à associer les chiffres aux équipes, une sorte de modulo 20 et après il faut que je trouve une manière de mettre ces chiffres en mémoire et de les additionner. J'ai déjà fait une listeannée et une listevilles.

Vos idées sont les bienvenues, peut être que ça vous paraitra simple ou pas très clair dans ce cas j'attends vos réactions Merci !

[josmiley]

ça simplifierait d'attribuer des points directement au lieu de rang ...

genre:
classement = {
monaco:[20,17,19,20,18],
lyon: [19,16,20,18,19]
}

ainsi monace en 2003:
classement[monaco][3] retourne 20, il était 1er
sum(classement[monaco]) donne 94 points
etc ...

on peut aussi faire avec une structuer de ce genre:
classement = {
2000:[monaco,lyon,.,.,.],
2001: [lyon,marseille,.,.,.]
}

[N.tox]

Pour résoudre ta problématique, tu auras besoin de connaître quelque méthodes des objets str :

• isdigit
• isalpha
• strip

voici quelque exemple d'utilistions et et des résultats retournés :

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
>>> '0123'.isdigit()
True
>>> '0123'.isalpha()
False
>>> 'abc'.isdigit()
False
>>> 'abc'.isalpha()
True
>>> 'a1'.isdigit()
False
>>> 'a1'.isalpha()
False
>>> '  \tfoo\t\t\n  '.strip()
'foo'
>>> '  \tfoo fooooooo\t\t\n  '.strip()
'foo fooooooo'

Il te sera également utile de savoir ceci :

Code :

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

1
2
3
4
5
6
7
>>> with open('d:\\toto.bak') as f_in:
	for line in f_in:
		print([line])
 
 
['client\n']
['\tmsg']

Je te laisse réfléchir et trouver la solution, ce qui est bien plus gratifiant et marquant

Edit : t'auras aussi besoin d'un dictionnaire

Code :

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

1
2
3
4
5
6
7
>>> dico = {'a':1}
>>> dico
{'a':1}
>>> dico['a'] += 1
>>> dico['b'] = 2
>>> dico
{'b':2, 'a':2}

[targui86]

le mieux c'est d'utilisé les dictionnaires et les listes
exemple: équipes={psg:{année:2000,point:13,but:1056,encaissée:954},monaco:{année:1999,point:14,but:1545,encaissée:895}.....}

[fred1599]

Autant créer une classe Equipe, me semble plus adapté à la demande et la POO s'y prête vraiment bien dans ce genre de cas.

Code :

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

1
2
3
4
5
6
7
8
>>> class Equipe():
	pass
 
>>> PSG = Equipe()
>>> PSG.point = 20
>>> PSG.point += 1
>>> print(PSG.point)
21

[afranck64]

Concernant, la lecture du fichier et le décompte des points, vous pouvez procéder comme suit:

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
#!/usr/bin/env python
 
txt = """2000
Monaco
Lyon
2001
Lyon
Marseille
2002
PSG
Monaco
Turin
Lyon
Marseille"""
 
def parse(txt):
    lst = txt.splitlines()
    res = []
    cur = []
    for elmt in lst:
        if elmt.isdigit():
            if (cur):
                res.append(cur)
            cur = []
            cur.append(int(elmt))
        else:
            cur.append(elmt)
    if (cur):
        res.append(cur)
    return res
 
 
def getPoints(name, lst):
    total = 0
    for elmt in lst:
        if name in elmt:
            total += 21 - elmt.index(name)
    return total
 
def getPointsYear(name, year, lst):
    for elmt in lst:
        if (elmt and elmt[0]==year and (name in elmt)):
            return 21 - elmt.index(name)
    return 0
 
def main():
    lst = parse(txt)
    print lst
    print getPoints("Marseille", lst), " pts pour Marseille"
    print getPoints("Lyon", lst), " pts pour Lyon"
    print getPointsYear("PSG",2002, lst), "pts pour le PSG en 2002"
 
if __name__ == '__main__':
    main()

Bien entendu, le traitement d un fichier ne devrait se faire qu une fois.
Je pense qu aprés avoir chargé les donnés dans la liste, vous aurez la possibilité de les gérer à votre guise.

[josmiley]

si une année, il n'y a que 18 équipes et non 20 par exemple, les points attribués commencent à 20 ou 18 ?

voilà un code qui utilise une class dérivé de dict ...

monfichier:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
2000
Monaco
Lyon
2001
Lyon
Marseille
2002
PSG
Monaco
Turin
Lyon
Marseille

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
class Palmares(dict):
 
    def __init__(self,file_):
        with open(file_) as pal:
            for p in pal.readlines():
                p = p.strip()
                if p.isnumeric():
                    annee = int(p)
                    self[annee] = []
                else:
                    super().__getitem__(annee).append(p)
        for annee in self:
            self[annee] = dict(zip(super().__getitem__(annee),range(20,0,-1)))
 
    def __getitem__(self,item):
        if type(item) == int:
            return super().__getitem__(item)
        else:
            return dict([(annee,ville[item])for annee,ville in self.items()if item in ville])
 
 
p = Palmares("monfichier")
print(p)
# {2000: {'Lyon': 19, 'Monaco': 20}, 2001: {'Lyon': 20, 'Marseille': 19}, 2002: {'Lyon': 17, 'Marseille': 16, 'Turin': 18, 'PSG': 20, 'Monaco': 19}}
print(p[2002])
# {'Lyon': 17, 'Marseille': 16, 'Turin': 18, 'PSG': 20, 'Monaco': 19}
print(p[2002]["Monaco"])
# 19
print(p["Monaco"])
# {2000: 20, 2002: 19}
print(p["Monaco"][2002])
# 19