Discussion :

[Kurodiam]

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 :

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
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

[Kurodiam]

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 :

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

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 ?

[Invité]

Bonjour,

Que de complications pour pas grand-chose :

Code :

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

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

@+.

[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
Euh ... j'ai prit 4 jours pour arriver à un code potable par rapport aux exigences de l'exercice .

[Invité]

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

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.

@+.

[Luke spywoker]

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

Code :

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

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.

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 :

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
 
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.