Affichage d'un dico

Version imprimable

Affichage d'un dico

Bonjour,

J'ai vu un code qui utilisait le formatage des chaines (qui ressemble à une fonction de hackage) pour créer un dico anglais/français , j'ai utilisé la méthode dict(zip..) et sorted () , mais je n'arrive à faire un affichage correct avec un dico tabulé + saut de ligne + alignement , ce n'est que vers la fin de mon code que j'arrive à un certain alignement :? (plutôt du hasard mais je ne pense que la neutralisation de l'alinéa soit suffisant avec une virgule) . Si je crée un dico A/F avec dict(zip...) , la méthode du % pour inverser l'ordre ne sert à rien et même cette méthode '%s\t%s\n' pour manipuler les chaines dans une liste , ne marcherait pas sur un dico qui comporte des clés et valeurs ... A moins d'utiliser la méthode items() qui renvoie un tuple des clés et valeurs .

J'ai essayé au début d'extraire des tuples des valeurs des clés du dico , mais je n'obtiens pas un résultat concret :( , la méthode keys() et values() pourraient servir mais ceci reviendrait à un formatage des chaines .Par ailleurs , j'ai limité volontairement la taille du dico pour corriger quickly et insérer des print partout ...

Je me suis inspirée du site qui est très intéressant pour la résolution du problème http://christophe.boilley.free.fr/py...s.html#chaines

Code:

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
>>> li = ['blue', 'black']
>>> du = ['bleu', 'noir']
>>> var = dict(zip(li,du))
>>> var
{'blue': 'bleu', 'black': 'noir'}
>>> durr = {}
>>> for ligne in var :
	ligne= var.get('blue','?'),var.get('black','?')
	print ligne
 
 
('bleu', 'noir')
('bleu', 'noir')
>>> var
{'blue': 'bleu', 'black': 'noir'}
>>> d = {}
>>> for t in var :
	t = var.get('blue','?'),var.get('black','?')
	d += {'%s\t%s\n' % (var.get('blue','?'), var.get('black','?'))}
	print d
 
 
 
Traceback (most recent call last):
  File "<pyshell#17>", line 3, in <module>
    d += {'%s\t%s\n' % (var.get('blue','?'), var.get('black','?'))}
TypeError: unsupported operand type(s) for +=: 'dict' and 'set'
>>> for t in var :
	t = var.get('blue','?'),var.get('black','?')
	d += '%s\t%s\n' % (var.get('blue','?'), var.get('black','?'))
	print d
 
 
 
Traceback (most recent call last):
  File "<pyshell#19>", line 3, in <module>
    d += '%s\t%s\n' % (var.get('blue','?'), var.get('black','?'))
TypeError: unsupported operand type(s) for +=: 'dict' and 'str'
>>> for t in var :
	t = var.get('blue','?'),var.get('black','?')
	d = '%s\t%s\n' % (var.get('blue','?'), var.get('black','?'))
	print d
 
 
bleu	noir
 
bleu	noir
 
>>> u ={}
>>> for i in var:
	i = var['blue'],var['black']
	print i
	u = '%s\t%s\n' % (var.get('blue','?'), var.get('black','?'))
	print u
 
 
('bleu', 'noir')
bleu	noir
 
('bleu', 'noir')
bleu	noir
 
>>> o = {}
>>> for e in var :
	e = var['blue'],var['black']
	o = '%s\t%s\n' % (var['blue'],var['black'])
	print o
 
 
bleu	noir
 
bleu	noir
 
>>> b = {}
>>> for j in var :
	j = var['blue'],var['black']
	var = '%s\t%s\n' % j
	print var
 
 
bleu	noir
 
 
Traceback (most recent call last):
  File "<pyshell#42>", line 2, in <module>
    j = var['blue'],var['black']
TypeError: string indices must be integers, not str
>>> var
'bleu\tnoir\n'
>>> var = '%s\t%s\n' % j
 
Traceback (most recent call last):
  File "<pyshell#44>", line 1, in <module>
    var = '%s\t%s\n' % j
TypeError: not enough arguments for format string
>>> var = {'blue': 'bleu', 'black': 'noir'}
>>> j = var['blue'],var['black']
>>> j
('bleu', 'noir')
>>> var = '%s\t%s\n' % j
>>> var
'bleu\tnoir\n'
>>> var = {'blue': 'bleu', 'black': 'noir'}
>>> p = {}
>>> for y in var :
	y = var.values()
	print y
 
 
['bleu', 'noir']
['bleu', 'noir']
>>> var = {'blue': 'bleu', 'black': 'noir'}
>>> o = '%s\t%s\n' % var
 
Traceback (most recent call last):
  File "<pyshell#58>", line 1, in <module>
    o = '%s\t%s\n' % var
TypeError: not enough arguments for format string
>>> o = {}
>>> o = '%s\t%s\n' % var
 
Traceback (most recent call last):
  File "<pyshell#60>", line 1, in <module>
    o = '%s\t%s\n' % var
TypeError: not enough arguments for format string
>>> var = {'blue': 'bleu', 'black': 'noir'}
>>> def prd(var) :
	for c in sorted(var) :
		print '\t', c, ':', var[c]
 
 
>>> prd(var)
	black : noir
	blue : bleu
>>> var = {'blue': 'bleu', 'black': 'noir'}
>>> def prd(var) :
	for e in sorted(var) :
		print '\t', z, '    ', var[e]
 
 
>>> prd(var)
 
Traceback (most recent call last):
  File "<pyshell#74>", line 1, in <module>
    prd(var)
  File "<pyshell#73>", line 3, in prd
    print '\t', z, '    ', var[e]
NameError: global name 'z' is not defined
>>> def prd(var) :
	for e in sorted(var) :
		print '\t', e, '    ', var[e]
 
 
>>> prd(var)
	black      noir
	blue      bleu
>>> var
{'blue': 'bleu', 'black': 'noir'}
>>> def prd(var) :
	for z in sorted(var) :
		print '%s\t%s\n', z, '    ', var[z]
 
 
>>> prd(var)
%s	%s
black      noir
%s	%s
blue      bleu
>>> def prd(var) :
	for t in sorted(var) :
		print '\t\n', t, '    ', var[t]
 
 
>>> prd(var)
 
black      noir
 
blue      bleu
>>> def prd(var) :
	for g in sorted(var) :
		print '\t%s\n', g,'\t ', var[g]
 
 
>>> prd(var)
	%s
black 	  noir
	%s
blue 	  bleu
>>>

Bonne journée :mrgreen:

Durant l'aprem , j'ai crée un code avec une simple liste en utilisant : tuple , la méthode sort(), et la méthode join() mais c'est une approche fonctionnelle .
Code:

1 2 3 4 5 6 7 8 9 10 11 >>> FA = [ ("bleu", "blue"), ("vert", "green"), ("yellow", "jaune") ] >>> FA.sort() >>> print '\n'.join(['%s\t %s\t' % (couleur, trad) for trad, couleur in FA]) blue bleu green vert jaune yellow >>>
Est-ce que mon code est bon ? Là , j'ai fait des efforts pour piocher ...

Et surtout comment arriver à créer un fichier .txt avec la méthode open() et write() lorsque que l'affichage dans mon code se fait avec un print ?

Je vais devoir faire de toutes façons: FA = open("dico",'w') et puis le code , non ?

Bonjour,

Que de complications pour pas grand-chose :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
dico = {
    "blue": "bleu",
    "green": "vert",
    "yellow": "jaune",
}
 
for key in sorted(dico):
 
    print("{en}\t{fr}".format(en=key, fr=dico[key]))
 
# end for

@+.

14/07/2014, 23h02
Kurodiam

Merci pour ta réponse :)

Je suis en L1 , je n'ai malheureusement pas encore vu la méthode format() et encore moins "{en}\t{fr}" (sauf le '\t ' ), toi , tu fais appel directement au module des dicos de langues , non ?

En tout cas, je connais un peu la méthode sorted() , bien que j'ai eu du mal à l'utiliser dans mon premier post : ce qui veut dire que ton code est plus efficace et que l'utilisation des méthodes values() et keys() s’avère compliquer à réaliser 8O
Euh ... j'ai prit 4 jours pour arriver à un code potable par rapport aux exigences de l'exercice :weird: .
14/07/2014, 23h11
Invité

Citation:

Envoyé par Kurodiam

Merci pour ta réponse :)

Je suis en L1 , je n'ai malheureusement pas encore vu la méthode format() et encore moins "{en}\t{fr}" , toi , tu fais appel directement au module des dicos de langues , non ?

En tout cas, je connais un peu la méthode sorted() , bien que j'ai eu du mal à l'utiliser dans mon premier post : ce qui veut dire que ton code est plus efficace et que l'utilisation des méthodes values() et keys() s’avère compliquer à réaliser 8O

Quitte à faire un dico de traduction, autant se servir de la langue à traduire comme clé de référence pour la langue traduite e.g. dico = {"english key": "clé anglaise"}.

La relation clé/valeur de l'objet Python dict() étant directe, on n'a pas besoin de passer par d'autres opérations.

La seule contrainte demeure le tri par ordre alphabétique des clés du dico => ce que sorted(dico) fournit aisément.

Quant à recourir à dict().keys() ou dict().values() => ce n'est tout simplement pas utile dans le cas de figure ici présent.

Faire simple est plus compliqué qu'il n'y paraît : c'est même là tout l'art du développeur. ;)

@+.

Salut,
en faites il existe une classe OrderedDict dans le module collections, dont l'instance créer par un appel a:
Code:

1 2 3 4 5 from collections import OrderedDict b=OrderedDict() b['rouge']='red' b['vert']='green' b['bleu']='blue'
est ordonner en fonction des entrées c.a.d le premier item entré et le premier du classement quand ont se sert des itérateurs ('.iteritems', '.iterkeys', '.itervalues', '.keys','.values','.items' ) de la classe OrderedDict.

Citation:

class collections.OrderedDict([items])

Return an instance of a dict subclass, supporting the usual dict methods. An OrderedDict is a dict that remembers the order that keys were first inserted. If a new entry overwrites an existing entry, the original insertion position is left unchanged. Deleting an entry and reinserting it will move it to the end.

Mais je crois que c'est pas le but de classement recherché pour un objet de type dict qui représente un dictionnaire fr/en, mais plutôt un classement alphabétique je pense. Alors on peut rentrés les données dans l'ordre depuis 1 objets ordonnable comme une liste constituer de tuples pair de mots fr/en.
Que l'on pourrait lire d'un fichier et aisément ordonner dans le deux sens grâce a la méthode sorted() qui pour précision peut prendre en argument 2 fonctions:

key= Une fonction, prenant en paramètre un item de la liste, renvoyant la partie de l'item a prendre en compte pour établir l'ordre désiré.
cmp= Une fonction prenant en paramètre 2 items de la liste renvoyant la façon dont 2 items doivent être ordonner représenter par 3 chiffres différents: -1 (plus petit, avant), 0 (égale), 1 (plus grand, après).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 a=[('blue','blue'),('vert','green'),('rouge','red')] def keys_fr(elt) : return elt[0] def keys_en(elt) : return elt[1] def compare(elt1,elt2) : if ord(elt1[0]) < ord(elt2[0]) : return -1 elif ord(elt1[0]) > ord(elt2[0]) : return 1 else : return 0 sorted(a,cmp=compare,key=keys_en) [('blue', 'blue'), ('vert', 'green'), ('rouge', 'red')] sorted(a,cmp=compare,key=keys_fr) [('blue', 'blue'), ('rouge', 'red'), ('vert', 'green')]
La suite est évidente: ont peut rentrés les items par indexage des tuples, grâce a une affectation du résultat de la primitive sorted().
Bien sur il faut affûter la fonction compare() pour un plus gros volume de données.

15/07/2014, 14h40
Kurodiam

Merci pour l'explication .

Notre professeur nous dit d'aller toujours vers le plus simple , donc ta solution n'est pas encore de mon niveau , mais celle de @tarball69 est plus simple à appliquer .
D'ailleurs, lorsqu'il y'a des lignes vides dans un dico, il faudrait créer une fonction pour les neutraliser , du moins une fonction capable de détecter si la longueur de la liste et si elle est vide (donc espace en blanc)

Peut être un Try /Except ?

PS: l'avantage d'une liste , on pourra toujours utiliser la méthode append() , mais pour le dico aussi , mais c'est lourd dico['mot'] = 'livre' . Je trouve que le chap des dicos contient pleins de méthode mais trop statiques ...

Citation:

Notre professeur nous dit d'aller toujours vers le plus simple , donc ta solution n'est pas encore de mon niveau...

D'accord j'ai expliquer quelque chose qui me semble relativement facile de manière a ce que ca te paraisse compliquer mais je ne voit pas comment, si il faut, ordonner ton dico alphabétiquement ne pas passer par une liste et la méthode de l'objet de type list, car en python tout est objet (Notion du type de base d'un langage de programmation: demande a ton prof !) la méthode sorted().

Et je me demande aussi pourquoi personne ne réagit a la parution de mes 2 derniers programmes sur aucun site ou j'en ai fait la promo.

Mais revenons a sorted()

La méthode peut prendre 2 arguments optionnel changeant la façon d'ordonner la liste: par défaut le liste est ordonner lexicographiquement (regarde dans un dico (d'informatique)) :

Sous forme de fonctions, ont appel cela des callback:

une fonction cmp: que tu peut nommer comme bon te semble et dont le nom doit être passer comme argument cmp=nom_de_fonction.

Qui doit avoir comme squelette:
Code:

1 2 3 4 5 6 7 8 9 10 def ma_fonction_cmp(element_1,element_2) : # ici des structures conditionnelles (if, elif else) pour comparer les 2 éléments: # # element_1 et element_2 qui représente 2 items de la liste a comparer (sachant que tous les items seront comparés par cette fonction). # # et renvoie de (return) : # 1 pour plus grand # -1 pour plus petit # 0 pour égale.
une fonction key: que tu peut nommer comme bon te semble et dont le nom doit être passer comme argument key=nom_de_fonction.

Qui doit avoir comme squelette:
Code:

1 2 3 4 5 6 def ma_fonction_key(element) : # renvoie en fonction des items de ta liste de la partie de l'item que tu souhaite trier. # par exemple si ta liste contient des 2-tuples ('fr','en'), # Et que tu souhaite trier en fonctions du français il faut renvoyer le premier item du tuple ('fr','en') sous forme indexer: # return element[0] # element est le paramètre de la fonction.
Pour finir le code d'ordonnancement du post précédent:
Code:

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 #!/usr/bin/python # -*- coding: utf-8 -*- from collections import OrderedDict a=[('bleu','blue'),('vert','green'),('rouge','red')] def keys_fr(elt) : return elt[0] def keys_en(elt) : return elt[1] def compare(elt1,elt2) : if ord(elt1[0]) < ord(elt2[0]) : return -1 elif ord(elt1[0]) > ord(elt2[0]) : return 1 else : return 0 list_fr_en=sorted(a,cmp=compare,key=keys_fr) dico_fr_en=OrderedDict() # Important d'utiliser un OrderedDict pour préserver l'ordre. for v in list_fr_en : dico_fr_en[v[0]]=v[1] # remplissage du dico par indexage de l'itérateur de la liste. print "*** dico fr/en ***" for fr,en in dico_fr_en.iteritems() : print fr,'=',en list_en_fr=sorted(a,cmp=compare,key=keys_en) dico_en_fr=OrderedDict() # Important d'utiliser un OrderedDict pour préserver l'ordre. for v in list_en_fr : dico_en_fr[v[1]]=v[0] # remplissage du dico par indexage de l'itérateur de la liste. print "*** dico en/fr ***" for en,fr in dico_en_fr.iteritems() : print en,'=',fr
Bon python a toi :).

22/07/2014, 17h22
Kurodiam

Merci pour ton aide !

Juste comme précision , ton niveau est beaucoup plus élevé que le mien , et je ne maitrise pas encore toutes les astuces de codage . J'ai encore du mal à saisir certains messages d'erreurs de python :?. Toi , tu jongles facilement algorithmiquement , ce n'est pas encore mon cas *.* .
Cependant , pour l'instant , en cours , on a utilisé la méthode sorted() avec un argument ...