Discussion :

[l1informatique]

un exercice me rend vraiment folle, le problème je ne sais pas comment m'y prendre pour le résoudre,je veux des conseils et plus d'explication svp.

le code est :

Code :

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

1
2
3
4
5
6
7
def pilote(fichier, dex) : 
      flux = open(fichier, 'r') 
      for n, ligne in enumerate(flux) : 
              dex = indexe(dex, ligne.split(), n + 1) 
      flux.close() 
      prd(dex) 
      return dex

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
def indexe(dex, mots, ligne) : 
      for mot in mots : 
              mot = nettoie(mot) 
              if mot.lower() in stoplist : pass 
              else : dex = ajoute(dex, mot, ligne) 
      return dex 
 
def ajoute(dex, mot, ligne) : 
      if mot in dex : 
              if ligne in dex[mot] : pass 
              else : dex[mot].append(ligne) 
      else : dex[mot] = [ligne] 
      return dex

Code :

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

1
2
3
4
5
6
ponctuation = '(,.")'                                                                                                                                                                                  
 
def nettoie(mot) :                                                                                                                                                                                     
     if mot[-1] in ponctuation : mot = mot[:-1]                                                                                                                                                         
     if mot[0] in ponctuation : mot = mot[1:]                                                                                                                                                           
     return mot

Code :

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

1
2
3
4
5
6
7
def prd(d) :  
      for c in sorted(d) : 
              print '\t', c, ':', d[c] 
 
 
 
stoplist = 'ce de du en le la mais on ou par pas pour qui un une'.split()

Code :

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

1
2
3
4
5
6
flux = open('stop.list', 'w')                                                
flux.write('\n'.join(stoplist))                                              
flux.close()
flux = open('stop.list', 'r')
stoplist = flux.read().split()
flux.close()

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
 
pilote('indexe-moi', {}) 
        alors : [8]
        attendue : [6]
        autrement : [7]
        avant : [6]
        avec : [8]
        avoir : [5]
        bien : [1, 5]
        bon : [9]
        bouts : [4]
        c'est : [1, 2, 3]
        certitude : [5]
        chaque : [4, 8]
        coder : [3]
        contexte : [8]
        dans : [6]
        dit : [7]
        expression : [4, 6]
        fonctionnement : [9]
        frustration : [3]
        garantit : [9]
        global : [9]
        grosse : [3]
        instruction : [7, 8]
        large : [7]
        mal : [2]
        marche : [2]
        petits : [4]
        plaisir : [1]
        plus : [6]
        programme : [1, 2, 7]
        progressivement : [4, 9]
        qu'elle : [5]
        retourne : [5]
        s'en : [6]
        servir : [6]
        solution : [3]
        testant : [4]
        teste : [8]
        tourne : [1]
        tout : [2]
        valeur : [5]
        voulu : [8]
        vraiment : [2]
{'certitude': [5], 'progressivement': [4, 9], 'global': [9], 'grosse': [3], 
'plaisir': [1], 'retourne': [5], 'coder': [3], 'avec': [8], 'alors': [8], "c'est": [1, 2, 3], 
'attendue': [6], 'bien': [1, 5], 'chaque': [4, 8], 'valeur': [5], 'frustration': [3], "s'en": [6], 
'autrement': [7], 'plus': [6], 'avoir': [5], 'testant': [4], 'tourne': [1], 'bouts': [4], 'vraiment': [2], 'petits': [4], 
'teste': [8], 'garantit': [9], 'mal': [2], 'marche': [2], 'expression': [4, 6], 'instruction': [7, 8], 'dans': [6], 'solution': [3], 
'large': [7], 'fonctionnement': [9], 'tout': [2], 'voulu': [8], 'bon': [9], 'dit': [7], 'avant': [6], 'servir': [6], "qu'elle": [5], 
'contexte': [8], 'programme': [1, 2, 7]}

le fichier qui s'appelle indexe-moi enregistrer sous gedit est :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
Un programme qui tourne bien, c'est un plaisir, mais un 
programme qui marche mal ou pas du tout, c'est vraiment 
une "grosse" frustration. La solution c'est de le coder par 
petits bouts, en testant progressivement chaque expression 
pour avoir la certitude qu'elle retourne bien la valeur 
attendue, avant de s'en servir dans une expression plus 
large, autrement dit une "instruction" du programme. On 
teste alors chaque instruction avec le contexte voulu, ce 
qui, progressivement, garantit le bon fonctionnement global.

et la question de l'exercice est :

la fonction prd() est très commode pour afficher les données, mais ce n'est pas comme ça qu'un typographe professionnel présenterait l'index d'un ouvrage " : le lecteur n'a que faire des “[]” " ;
modifier cette fonction pour que la liste de lignes soit présentée sous la forme " : programme : 1-2, 7 " ; quand il y a 2 numéros consécutifs ou plus, par exemple, 1, 2, 3, 5
, la liste est présentée sous la forme 1-3, 5 " : coder cette présentation


je sais que je dois donner au moins une proposition mais j'ai aucune,je suis bloqué :s

merci

[VinsS]

Salut,

Il faut jouer avec le formatage en énumérant les chiffres triés préalablement.

Exemple:

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
 
for key in sorted(d):
    value = d[key]
    if len(value) == 1:
        num = value[0]
    else:
        value = sorted(value)
        num = "%s" % value[0]
        sep = ", "
        for idx, c in enumerate(value[1:]):
            if c == value[idx] + 1:
                sep = "-%s, " % c
            else:
                num = num + sep + str(c)
                sep = ", "
        if sep != ", ":
            num = num + sep
 
    print "\t%s: %s" %(key, num)

[l1informatique]

j'ai rien compris :s

apparemment il y a une fameuse liste que nous devons passer à la fonction

et un nombre variable d'entiers (entier = le numéro de page) :

Ce que je veux c'est :

- D'une part, virer les crochets (c'est pour ça qu'on doit retourner impérativement une str).

- Trouver les pages qui se suivent, et n'afficher que la première page de cette suite, suivie d'un tiret, puis la dernière page de cette suite (ce que j'appele bornes de gauche et bornes de droite. Le tout avec un tiret = intervalle).

Le principal traitement de cette fonction donc, ça va être d'itérer sur cette liste immonde qu'on veut changer, et de repérer quelles pages se suivent, et quelles pages ne sont suivies / ne suivent aucune autre page (pages seules donc).

[VinsS]

C'est exactement ce que j'avais compris.

Teste ceci:

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
 
# -*- coding: utf-8 -*-
 
d = {'certitude': [5], 'progressivement': [4, 9], 'global': [9], 'grosse': [3], 
'plaisir': [1], 'retourne': [5], 'coder': [3], 'avec': [8], 'alors': [8], "c'est": [1, 2, 3], 
'attendue': [6], 'bien': [1, 5], 'chaque': [4, 8], 'valeur': [5], 'frustration': [3], "s'en": [6], 
'autrement': [7], 'plus': [6], 'avoir': [5], 'testant': [4], 'tourne': [1], 'bouts': [4], 'vraiment': [2], 'petits': [4], 
'teste': [8], 'garantit': [9], 'mal': [2], 'marche': [2], 'expression': [4, 6], 'instruction': [7, 8], 'dans': [6], 'solution': [3], 
'large': [7], 'fonctionnement': [9], 'tout': [2], 'voulu': [8], 'bon': [9], 'dit': [7], 'avant': [6], 'servir': [6], "qu'elle": [5], 
'contexte': [8], 'programme': [1, 2, 3, 4, 5, 7, 8, 9]}
 
for key in sorted(d):
    # 
    value = d[key]
    if len(value) == 1:
        #
        num = value[0]
    else:
        #
        value = sorted(value)
        num = "%s" % value[0]
        sep = ", "
        #
        for idx, c in enumerate(value[1:]):
            if c == value[idx] + 1:
                #
                sep = "-%s, " % c
            else:
                #
                num = num + sep + str(c)
                sep = ", "
 
        if sep != ", ":
            #
            num = num + sep
 
    print "\t%s: %s" %(key, num)

Ensuite, mets un commentaire après chaque # que j'ai ajouté au code pour montrer que tu as compris.

[l1informatique]

le but de l'exercice c'est : d'avoir exemple pour exemple : programme[1,2,3,7,11,12,13,15] une chaine de programme = "1-3,7,11-13,15"

[wiztricks]

le but de l'exercice c'est : d'avoir exemple pour exemple : programme[1,2,3,7,11,12,13,15] une chaine de programme = "1-3,7,11-13,15"

Fastoche:

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
>>> from operator import itemgetter
>>> from itertools import groupby
>>>
>>> def g_intervals(data):
...     for k, g in groupby(enumerate(data), lambda (i,x): i-x ):
...         range = map(itemgetter(1), g )
...         if len(range) > 1:
...             yield '%d-%d' % (range[0], range[-1])
...         else:
...             yield '%d' % range[0]
...
>>> data = [1,2,3,7,11,12,13,15]
>>> ranges = list(g_intervals(data))
>>> print ', '.join(ranges)
1-3, 7, 11-13, 15
>>>

- W