Discussion :

[Boule181]

Bonjour !

Je fait partie d'une petite association de bricoleurs amateur passionné de Raspberry pi et Arduino. Nous nous retrouvons une fois par semaine dans un local.

Le bricoleur est un animal qui aime se désaltérer et manger régulièrement et nous avons un petit stock à entrenir.

C'est dans ce contexte que j'ai commencé un script python pour la gestion dudit stock à l'aide d'un Raspberry Pi et d'une douchette à code-barre.

Soyer indulgent, je débute avec Python ;-)


Mon problème :

J'ai quatre liste :

Code :

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

1
2
3
4
ListeBarcodes = ['101','201','102','103','202','203'] #
ListeProduits = ["Fanta","Kriek","Schweppes Agrum","Coca Cola","Hoegarden","Jupiler"]
ListePrix = [1,1.5,1,1,1.5,1.5]
ListeGenres = ["Soft","Spécial","Soft","Soft","Spécial","Spécial"]

Dans mon programme, l'index de de la liste ListeBarcode conditionne l'index des autres listes. Bref comme un tableau rangé par colonne.
Je ne veux pas entendre : "Fallait faire un tableau !". La structure de mon prog ferait certainement pleurer un puriste mais il fonctionne et je ne veux plus le refaire une 7ème fois... ;-)

Je précise que ces listes n'auront jamais un nombre d'élément définitif. Je peux, à tout moment, ajouter, supprimer ou éditer des produits ainsi que créer des genres différent.

Je voudrais agencer ces quatre listes (sans perturber les "colonnes") avant de m'en servir, vai print, pour afficher clairement une liste du stock complet par genre :

Code :

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

1
2
3
4
5
6
Soft ........ Schweppes Agrum : 1   Euro    (102)
Soft ........ Fanta           : 1   Euro    (101)
Soft ........ Coca Cola       : 1   Euro    (103)
Spécial ..... Kriek           : 1.5 Euro    (201)
Spécial ..... Hoegarden       : 1.5 Euro    (202)
Spécial ..... Jupiler         : 1.5 Euro    (203)

Jusque-là, j'y arrive. c'est maintenant que je coince car je voudrais aller plus loin pour obtenir ceci :

Code :

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

1
2
3
4
5
6
7
Soft ........ Coca Cola       : 1   Euro    (103)
Soft ........ Fanta           : 1   Euro    (101)
Soft ........ Schweppes Agrum : 1   Euro    (102)
 
Spécial ..... Jupiler         : 1.5 Euro    (203)
Spécial ..... Hoegarden       : 1.5 Euro    (202)
Spécial ..... Kriek           : 1.5 Euro    (201)

Bref garder le classement des genres et trier alphabétiquement chaque groupes de genres.

Des idées ? (de préférence simple à comprendre pour un le béotien que suis...)

[tyrtamos]

Bonjour,

La solution que j'utiliserais est celle d'une liste d'index.

On va considérer que l'ordre alphabétique de base est celui de la liste ListeBarcodes.
On va donc lui associer une liste [0,1,2,3,...] comme suit:

Code :

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

1
2
3
index = [i for i in range(0, len(ListeBarcodes))]
print(index)
[0, 1, 2, 3, 4, 5]

On va maintenant calculer une nouvelle liste d'index pour pouvoir afficher les 4 listes dans l'ordre alphabétique de ListeProduits sans changer ces listes.

Code :

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

1
2
3
ListeProduits_idx = sorted(index, key=lambda k: ListeProduits[k])
print(ListeProduits_idx)
[3, 0, 4, 5, 1, 2]

Qu'est-ce que ça veut dire? Que pour avoir la liste ListeProduits dans l'ordre alphabétique, il faut prendre l'élément 3, puis le 0, puis le 4, le 5, le 1 et enfin le 2.

On peut donc maintenant afficher les 4 listes dans l'ordre alphabétique de ListeProduits en utilisant la liste des index qu'on vient de calculer:

Code :

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

1
2
3
4
print([ListeBarcodes[idx] for idx in ListeProduits_idx])
print([ListeProduits[idx] for idx in ListeProduits_idx])
print([ListePrix[idx] for idx in ListeProduits_idx])
print([ListeGenres[idx] for idx in ListeProduits_idx])

Ce qui donnera:

Code :

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

1
2
3
4
['103', '101', '202', '203', '201', '102']
['Coca Cola', 'Fanta', 'Hoegarden', 'Jupiler', 'Kriek', 'Schweppes Agrum']
[1, 1, 1.5, 1.5, 1.5, 1]
['Soft', 'Soft', 'Spécial', 'Spécial', 'Spécial', 'Soft']

On voit bien que la synchronisation des éléments des différentes listes par colonne a été respectée.

On peut faire pareil pour les 2 autres listes.

On récapitule: si on reprend les 3 manières d'afficher les 4 listes, en plus de l'affichage "normal":

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
#============================================================================
# tri selon ListeProduits
print("*"*78)
# liste des index selon l'ordre de ListeProduits
ListeProduits_idx = sorted(index, key=lambda k: ListeProduits[k])
print(ListeProduits_idx)
print()
# affichage des 4 listes dans l'ordre de ListeProduits
print([ListeBarcodes[idx] for idx in ListeProduits_idx])
print([ListeProduits[idx] for idx in ListeProduits_idx])
print([ListePrix[idx] for idx in ListeProduits_idx])
print([ListeGenres[idx] for idx in ListeProduits_idx])
 
#============================================================================
# tri selon ListePrix
print("*"*78)
# liste des index selon l'ordre de ListePrix
ListePrix_idx = sorted(index, key=lambda k: ListePrix[k])
print(ListePrix_idx)
print()
# affichage des 4 listes dans l'ordre de ListePrix
print([ListeBarcodes[idx] for idx in ListePrix_idx])
print([ListeProduits[idx] for idx in ListePrix_idx])
print([ListePrix[idx] for idx in ListePrix_idx])
print([ListeGenres[idx] for idx in ListePrix_idx])
 
#============================================================================
# tri selon ListeGenres
print("*"*78)
# liste des index selon l'ordre de ListeGenres
ListeGenres_idx = sorted(index, key=lambda k: ListeGenres[k])
print(ListeGenres_idx)
print()
# affichage des 4 listes dans l'ordre de ListeGenres
print([ListeBarcodes[idx] for idx in ListeGenres_idx])
print([ListeProduits[idx] for idx in ListeGenres_idx])
print([ListePrix[idx] for idx in ListeGenres_idx])
print([ListeGenres[idx] for idx in ListeGenres_idx])

Ce qui donnera:

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
******************************************************************************
[3, 0, 4, 5, 1, 2]
 
['103', '101', '202', '203', '201', '102']
['Coca Cola', 'Fanta', 'Hoegarden', 'Jupiler', 'Kriek', 'Schweppes Agrum']
[1, 1, 1.5, 1.5, 1.5, 1]
['Soft', 'Soft', 'Spécial', 'Spécial', 'Spécial', 'Soft']
******************************************************************************
[0, 2, 3, 1, 4, 5]
 
['101', '102', '103', '201', '202', '203']
['Fanta', 'Schweppes Agrum', 'Coca Cola', 'Kriek', 'Hoegarden', 'Jupiler']
[1, 1, 1, 1.5, 1.5, 1.5]
['Soft', 'Soft', 'Soft', 'Spécial', 'Spécial', 'Spécial']
******************************************************************************
[0, 2, 3, 1, 4, 5]
 
['101', '102', '103', '201', '202', '203']
['Fanta', 'Schweppes Agrum', 'Coca Cola', 'Kriek', 'Hoegarden', 'Jupiler']
[1, 1, 1, 1.5, 1.5, 1.5]
['Soft', 'Soft', 'Soft', 'Spécial', 'Spécial', 'Spécial']

Je ne sais pas si ce sera assez simple, mais je n'ai pas mieux...

[Boule181]

Merci pour ces explications, elle m'ont permis de mieux comprendre cette technique que j'ai déjà utilisée "bêtement" en la recopiant depuis un exemple trouvé sur internet. ;-)

Par contre, cela ne résous pas ma question.

Dans ce que tu me présentes, il y a un seul tri identique effectué trois fois sur base d'un changement de liste de référence. Pour obtenir l'effet escompté avec ce simple tri, il aurait falu liste de référence telle que :

Code :

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

ListeGenresEtProduits = ["Soft Fanta","Spécial Kriek","Soft Schweppes Agrum","Soft Coca Cola","Spécial Hoegarden","Spécial Jupiler"]

Une solution me trotte en tête mais, je n'arrive pas a trouver de mise en oeuvre. Il s'agirait d'utiliser comme base cette méthode que tu m'a décrite :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
ListeProduits_idx = sorted(index, key=lambda k: ListeProduits[k])
print(ListeProduits_idx)
[3, 0, 4, 5, 1, 2]
 
print([ListeBarcodes[idx] for idx in ListeProduits_idx])
print([ListeProduits[idx] for idx in ListeProduits_idx])
print([ListePrix[idx] for idx in ListeProduits_idx])
print([ListeGenres[idx] for idx in ListeProduits_idx])
 
['103', '101', '202', '203', '201', '102']
['Coca Cola', 'Fanta', 'Hoegarden', 'Jupiler', 'Kriek', 'Schweppes Agrum']
[1, 1, 1.5, 1.5, 1.5, 1]
['Soft', 'Soft', 'Spécial', 'Spécial', 'Spécial', 'Soft']

Ensuite pour arriver à mon objectif l'idée serait, sur base du tri effectué, d'effectuer un triage linéaire. C'est à dire que sur l'analyse de ListeGenre, chaque fois que l'on rencontre "Soft" dans liste genre, un résultat est obtenu :

Code :

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

1
2
3
4
['103', '101', '102']
['Coca Cola', 'Fanta', 'Schweppes Agrum']
[1, 1, 1]
['Soft', 'Soft', 'Soft']

Pareil avec "Spécial".




J'avais tenté d'obtenir le résultat que je recherche en créant quatre listes en guise de tampon remplie par ce principe :

Code :

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

TamponListeBarcodes = ([ListeBarcodes[idx])

Ensuite j'avais fait un nouveau tri sur base des tampons créés avec comme référence d'index TamponListeGenres. A ma grande surprise, j'ai constaté que le traitement n'était pas linéaire car, si les genres étaient bien triés avec les colonnes respectées, les ordres alphabétique produits par rapport aux groupes des genres "Soft" et "Spécial" n'étaient plus juste.

[dividee]

Si j'ai bien compris, tu veux effectuer un tri multi-critères ?
Il suffit d'utiliser un tuple comme clé de tri:

Code :

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

ListeProduits_idx = sorted(index, key=lambda k: (ListeGenres[k],ListeProduits[k]))

[Invité]

Bonjour,

C'est en croyant "faire simple" que vous allez en réalité vous embourber dans du code compliqué pour pas grand-chose.

Ce que vous essayez de faire relève tout bêtement d'une base de données.

Et il en existe une toute simple à exploiter sous Python2/Python3 : sqlite3

doc officielle Python : https://docs.python.org/3/library/sqlite3.html

doc officielle SQLite : https://www.sqlite.org/lang.html

Ce sera plus laborieux à mettre en place, en revanche, une fois élaborée, votre base de données vous fera gagner beaucoup de temps.

Un exemple vite fait (sous Python3) :

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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
import sqlite3
 
class BDDJoyeuxBricoleurs:
    """
        base de données des joyeux bricoleurs;
    """
 
    def __init__ (self, **kw):
        # on crée la base de données
        self.connection = sqlite3.connect(
            kw.get("dbfile") or "joyeux_bricoleurs.db"
        )
        self.cursor = self.connection.cursor()
        # init structure BDD
        self.init_database(**kw)
    # end def
 
 
    def drink_add (self, fields=None, data=None):
        """
            ajoute une ou plusieurs boissons à la table 'drinks';
            @fields doit être une liste de noms de champs e.g.
            ['barcode', 'genre', 'designation', ...etc...] ou None si
            tous les champs doivent être renseignés; @data doit être
            une liste de listes ordonnées de données classées dans le
            même ordre que @fields e.g. [['101', 'Soft', 'Fanta'],
            ['102', 'Soft', 'Schweppes Agrum'], ...etc...];
        """
        # got data?
        if data:
            # inits
            _fields = ""
            _values = str(("?",) * len(data[0])).replace("'", "")
            # got fields
            if fields:
                _fields = str(tuple(fields))
                _values = str(("?",) * len(fields)).replace("'", "")
            # end if
            # SQL query
            self.cursor.executemany(
                "INSERT OR IGNORE INTO 'drinks' {} "
                "VALUES {}"
                .format(_fields, _values),
                data
            )
            self.connection.commit()
        # end if
    # end def
 
 
    def init_database (self, **kw):
        """
            on déclare ici la structure de la base de données;
        """
        # on crée la structure
        self.cursor.executescript("""
 
            -- table des boissons du club des joyeux bricoleurs
 
            -- DROP TABLE IF EXISTS 'drinks';
 
            CREATE TABLE IF NOT EXISTS 'drinks'
            (
                key                 INTEGER PRIMARY KEY,
                barcode             TEXT NOT NULL UNIQUE,
                genre               TEXT,
                designation         TEXT NOT NULL UNIQUE,
                unit_price          REAL,
                stock_qty           REAL
            );
        """)
        # on valide les données
        self.connection.commit()
    # end def
 
 
    def show_data_by (self, orderby="designation"):
        """
            affiche le contenu de la table 'drinks' trié par @orderby;
        """
        # affiche
        print("\nTABLE: 'drinks' ORDERED BY '{}' ASC".format(orderby))
        # récupère les lignes
        self.cursor.execute(
            "SELECT * FROM 'drinks' ORDER BY {} ASC".format(orderby)
        )
        _rows = self.cursor.fetchall()
        # oui?
        if _rows:
            # noms des champs
            print(
                "Columns:",
                tuple(c[0] for c in self.cursor.description or "")
            )
            # listing lignes
            print("Rows:")
            for _idx, _row in enumerate(_rows):
                print("{:03d}:".format(_idx + 1), tuple(_row))
            # end for
        else:
            print("This table is *empty*.")
        # end if
    # end def
 
# end class BDDJoyeuxBricoleurs
 
 
# =============================   DEMO   ===============================
 
# on lance la base de données
db = BDDJoyeuxBricoleurs()
 
# on remplit avec quelques données
db.drink_add(
    fields=("barcode", "genre", "designation", "unit_price", "stock_qty"),
    data=[
        ("101", "Soft", "Fanta", 1.00, 3),
        ("201", "Spécial", "Kriek", 1.50, 20),
        ("102", "Soft", "Schweppes Agrum", 1.00, 1),
        ("103", "Soft", "Coca-cola", 1.00, 10),
        ("202", "Spécial", "Hoegarden", 1.50, 5),
        ("203", "Spécial", "Jupiler", 1.50, 7),
    ]
)
 
# on vérifie le contenu de la base de données
# avec différents points de vue
db.show_data_by("designation")
db.show_data_by("barcode")
db.show_data_by("genre")
db.show_data_by("unit_price")
db.show_data_by("stock_qty")

Il ne vous reste plus qu'à présenter les données récupérées un peu mieux que ça et ça devrait suffire.

@+.

[Boule181]

@dividee

Oui, c'est ça, c'est du multi-critère ! Si j'avais pensé à le présenter comme ça mon premier post aurait été plus court !!!
Par contre, pourrait m'expliquer un peu cela ? J'ai lu que les tuples étaient non modifiable et, dans le cas de mon script, ça pourrait poser problème...

@tarball69

Bah, la simplicité, ce n'est pas drôle !

En fait ce projet est surtout pour moi un moyen concret d'apprendre à utiliser python.

sqlite est certainement très efficace, mais le plus gai, c'est de le faire soi-même.
et puis, c'est le concept de l'association qui est un hackerspace

Il ne vous reste plus qu'à présenter les données récupérées un peu mieux que ça et ça devrait suffire.

Justement, j'en suis également à ce point, présenter les données ! ^^

[dividee]

Par contre, pourrait m'expliquer un peu cela ? J'ai lu que les tuples étaient non modifiable et, dans le cas de mon script, ça pourrait poser problème...

Ne t'inquiète pas, ça ne posera pas de problème. C'est juste une modification toute à fait mineure du code proposé par tyrtamos. Les tuples en questions sont construits et détruits lors du tri, ils n'ont pas une durée de vie plus longue que ça. Ce qui est trié, c'est la liste d'indices, le tuple n'est là que pour gérer les comparaisons; la relation d'ordre sur les tuples est construite a partir de celles de ses éléments:

(A,B) <= (A',B') ssi A < A' ou [A = A' et B <= B']

et plus généralement:

(A,B,C,...) <= (A',B',C',...) ssi A < A' ou [A = A' et (B,C,...) <= (B',C',...)] (et le tuple vide est <= tout autre tuple)

d'ailleurs c'est la même chose sur les listes, tu peux utiliser des listes au lieu des tuples, si tu veux.

Code :

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

1
2
3
4
>>> ('Soft','Coca Cola') < ('Soft','Fanta')
True # 'Soft' == 'Soft' et 'Coca Cola' < 'Fanta'
>>> ('Soft','Schweppes') < ('Spécial','Jupiler')
True # 'Soft' < 'Spécial'

[Boule181]

Merci ! Je testerai ça demain ;-)

Je ne mets pas tout de suite en résolu, si quelqu'un a encore une idée...

[Clodion]

Bonsoir,
Pour le résultat demandé, c'est effectivement du multicritères…
Une autre solution, avec le principe de tyrtamos est d'effectuer deux tris de suite sur la liste d'index (en inversant l'ordre de tri).
-En premier, créer une liste d'index triée selon l'ordre de ListeProduits (critère secondaire de tri);
-En second, utiliser cette liste pour effectuer le tri selon le ListeGenres. C'est le critère principal de tri.

C'est le principe énoncé par dividee, mais par étapes (ce qui peut être plus aisé à comprendre):

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
ListeBarcodes = ['101','201','102','103','202','203'] #
ListeProduits = ["Fanta","Kriek","Schweppes Agrum","Coca Cola","Hoegarden","Jupiler"]
ListePrix = [1,1.5,1,1,1.5,1.5]
ListeGenres = ["Soft","Spécial","Soft","Soft","Spécial","Spécial"]
 
ListeProduits_idx = range(len(ListeProduits))
print("index des produits", *ListeProduits_idx)
 
ListeProduits_idx = sorted(range(len(ListeProduits)),
                           key = lambda x : ListeProduits[x])
print("tri des index sur la liste des produits", ListeProduits_idx)
 
ListeGenres_idx = sorted(ListeProduits_idx,
                           key = lambda x : ListeGenres[x])
print("Liste des index ordonnés par Produits puis par Genres", ListeGenres_idx)
for ind in ListeGenres_idx:
    print(ListeBarcodes[ind],
          ListePrix[ind],
          ListeGenres[ind],
          ListeProduits[ind],
          sep = "\t")

Code :

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

1
2
3
4
5
6
7
8
9
index des produits 0 1 2 3 4 5
tri des index sur la liste des produits [3, 0, 4, 5, 1, 2]
Liste des index ordonnés par Produits puis par Genres [3, 0, 2, 4, 5, 1]
103	1	Soft	Coca Cola
101	1	Soft	Fanta
102	1	Soft	Schweppes Agrum
202	1.5	Spécial	Hoegarden
203	1.5	Spécial	Jupiler
201	1.5	Spécial	Kriek

Bon, après, la solution de dividee en une étape est nettement plus jolie; celle de tarball69 sera efficace lorsque la cave grandira! :-)

Clodion

[Boule181]

Merci Clodion, je ne connaissait pas encore sep="" et end"". c'est pratique ! ;-)

J'ai fait un mix entre vos proposition et le peu que j'avais déjà compris avant de venir. Ça donne 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
ListeBarcodes = ['302','101','201','102','103','202','203','301'] 
ListeProduits = ["Tshirt","Fanta","Kriek","Schweppes Agrum","Coca Cola","Hoegarden","Jupiler","Clef Usb"]
ListePrix = [15,1,1.5,1,1,1.5,1.5,10]
ListeGenres = ["Goodie","Soft","Spécial","Soft","Soft","Spécial","Spécial","Goodie"]
 
IND = [i for i in range(0, len(ListeBarcodes))]
print(IND)
 
ListeProduits_idx = sorted(IND, key=lambda i: (ListeGenres[i],ListeProduits[i]))
print (ListeProduits_idx)
 
for i in range(0,len(ListeProduits_idx)):
 
	print((ListeBarcodes[ListeProduits_idx[i]]).ljust(6," "), end =" ")
	print((ListeGenres[ListeProduits_idx[i]]).ljust(10," "), end =" ")
	print((ListeProduits[ListeProduits_idx[i]]).ljust(20,"."), end =" ")
	print(ListePrix[ListeProduits_idx[i]],"euro",sep =" ")

Ce qui me retourne

Code :

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

1
2
3
4
5
6
7
8
9
10
[0, 1, 2, 3, 4, 5, 6, 7]
[7, 0, 4, 1, 3, 5, 6, 2]
301    Goodie     Clef Usb............ 10 euro
302    Goodie     Tshirt.............. 15 euro
103    Soft       Coca Cola........... 1 euro
101    Soft       Fanta............... 1 euro
102    Soft       Schweppes Agrum..... 1 euro
202    Spécial    Hoegarden........... 1.5 euro
203    Spécial    Jupiler............. 1.5 euro
201    Spécial    Kriek............... 1.5 euro

Un grand merci à tous !


J'ai cependant une dernière question : Comment, dans le print, aligner ma colone euro ?

cela fonctionne très bien avec l'argument sep="\t", mais ça me donne un graaand espace vide entre le prix et euro. Éstétiquement parlant, ce nest pas terrible...


Donc j'ai essayé ceci :

Code :

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

print(ListePrix[ListeProduits_idx[i]].ljust(20,"."),"euro",sep =" ")

qui me donne :

Code :

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

'int' object has no attribute 'ljust'

C'est pour moi une "surprise" qui n'a rien de surprenant pour vous...

J'en déduis que je dois convertir ListePrix dans un autre format.
J'ai tenté :

Code :

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

1
2
ListePrix_str = str(ListePrix)
print(ListePrix_str[ListeProduits_idx[i]].ljust(20,".")"euro",sep =" ")

[/CODE]

Résultat :

Code :

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

1
2
3
4
5
6
7
8
9
10
[0, 1, 2, 3, 4, 5, 6, 7]
[7, 0, 4, 1, 3, 5, 6, 2]
301    Goodie     Clef Usb............  ................... euro
302    Goodie     Tshirt.............. [................... euro
103    Soft       Coca Cola...........  ................... euro
101    Soft       Fanta............... 1................... euro
102    Soft       Schweppes Agrum..... ,................... euro
202    Spécial    Hoegarden........... 1................... euro
203    Spécial    Jupiler............. ,................... euro
201    Spécial    Kriek............... 5................... euro

ListePrix se retrouve un peu décomposé... et moi avec...

[Clodion]

J'ai cependant une dernière question : Comment, dans le print, aligner ma colone euro ?

cela fonctionne très bien avec l'argument sep="\t", mais ça me donne un graaand espace vide entre le prix et euro. Éstétiquement parlant, ce nest pas terrible...


Donc j'ai essayé ceci :

Code :

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

print(ListePrix[ListeProduits_idx[i]].ljust(20,"."),"euro",sep =" ")

qui me donne :

Code :

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

'int' object has no attribute 'ljust'

C'est pour moi une "surprise" qui n'a rien de surprenant pour vous...

J'en déduis que je dois convertir ListePrix dans un autre format.
J'ai tenté :

Code :

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

1
2
ListePrix_str = str(ListePrix)
print(ListePrix_str[ListeProduits_idx[i]].ljust(20,".")"euro",sep =" ")

[/CODE]

Résultat :

Code :

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

1
2
3
4
5
6
7
8
9
10
[0, 1, 2, 3, 4, 5, 6, 7]
[7, 0, 4, 1, 3, 5, 6, 2]
301    Goodie     Clef Usb............  ................... euro
302    Goodie     Tshirt.............. [................... euro
103    Soft       Coca Cola...........  ................... euro
101    Soft       Fanta............... 1................... euro
102    Soft       Schweppes Agrum..... ,................... euro
202    Spécial    Hoegarden........... 1................... euro
203    Spécial    Jupiler............. ,................... euro
201    Spécial    Kriek............... 5................... euro

ListePrix se retrouve un peu décomposé... et moi avec...

Bonjour,

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
>>> ListePrix = [15,1,1.5,1,1,1.5,1.5,10]
>>> lst = str(ListePrix)
>>> print(lst)
[15, 1, 1.5, 1, 1, 1.5, 1.5, 10]
>>> lst
'[15, 1, 1.5, 1, 1, 1.5, 1.5, 10]'
>>> lst[0]
'['
>>> lst_bis = [str(nb) for nb in ListePrix]
>>> print(lst_bis)
['15', '1', '1.5', '1', '1', '1.5', '1.5', '10']
>>> lst_bis
['15', '1', '1.5', '1', '1', '1.5', '1.5', '10']
>>> lst_bis[0]
'15'

L'erreur: ce n'est pas la liste qu'il faut convertir en chaîne, mais chacun de ses élément!!
(ie: c'est au niveau de print qu'il faut faire ce type de conversion)

Autre erreur: ljust s''applique à un type défini (str). C'est une méthode de cette classe (d'où le point entre l'instance de la classe et la méthode).
Et… ListePrix[ListeProduits_idx[i]] renvoie un entier ou un réel.

Clodion

[Boule181]

Merci à tous !

Je mets en résolu.