Discussion :

[leau2001]

bonjour

je m'essaye la creation de classe, mais j'ai déjà un soucis... je n'arrive pas à utiliser une methode de ma class dans une autre methode de ma class... le code : http://dpaste.com/90970/

Ce qui pose probleme c'est que mon print mes_data.coord_elm_pdf(25) ne m'affiche que des listes vides et que mon print lst_coord1 est lui aussi vide alors qu'il ne devrait pas...

Merci

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
 
class Data_Pdf:
    """classe representant les elements data d'un objet table de reportlab """
    def __init__(self,data_lst):
        """constructeur de l'objet """
        self._data_lst = data_lst
 
    def _lst_index_elm_list (self,elmt, liste):
        """methode qui trouve les index dans une liste d'une liste d'element"""
 
        data2 = liste
        lst_index =[]
 
        while data2.count(elmt) !=0 :
 
            id1=data2.index(elmt)
 
            lst_index.append(id1)
            data2[id1]='0'
 
        return lst_index
 
    def nbr_col (self) :
        self._nbr_col = len (self._data_lst[0])
        return self._nbr_col
 
    def nbr_lign (self) :
        self._nbr_ligne = len (self._data_lst)
        return self._nbr_ligne
 
    def coord_elm (self,elmt):
        x =0
        lst_coord1 =[]
        nbr_col = self.nbr_col()
        nbr_ligne = self.nbr_lign()
        for elm in self._data_lst :
 
 
            lst_y = self._lst_index_elm_list (elmt, elm)
 
            for elm in lst_y :
                coord1 =(x,elm)
                lst_coord1.append(coord1)
            x=x+1
        return lst_coord1
 
    def coord_elm_pdf (self,elmt) :
 
 
        lst_coord1 = self.coord_elm(elmt)
        print lst_coord1
        lst_coord_pdf =[]
        for elm in lst_coord1 :
 
            x2 = nbr_col-elm[0]
            y2 = nbr_ligne-elm[1]
            coord2 =(-x2,-y2)
            lst_coord_pdf.append((elm,coord2))
 
 
        return lst_coord_pdf
        pass
    def coord_elm_col (self) :
        pass
 
 
 
 
 
 
 
 
 
 
 
data = [ [50,25,50],[100,25,25],[80,20,20],[150,10,2] ]
 
 
 
mes_data = Data_Pdf (data)
print mes_data
print mes_data.nbr_col()
print mes_data.nbr_lign()
print mes_data.coord_elm(25)
print mes_data.coord_elm(50)
print mes_data.coord_elm_pdf(25)

[Antoine_935]

Ta question est vague, et ton code est, à mon goût bien sur, illisible.
A quelle ligne se situe ton problème d'"utilisation de méthode" ? Est-ce l'appel, la valeur de retour qui pose problème ?

[rambc]

Il faudrait proposer un ECM (Exemple Colmplet Minimal) qui montre ton problème car moi non plus je n'ai pas le courage de lire tes lignes de code.

[Tyrus]

j'ai lancé rapidemnt ton code est l'erreur est toute béte
tu a modifié ta list de référence
quand tu lance la premiére fois ta fonction
_lst_index_elm_list
l'attribut self._data_lst contient ça
[[50, 25, 50], [100, 25, 25], [80, 20, 20], [150, 10, 2]]

quant tu repasse pour obtenir le résultat de
print mes_data.coord_elm_pdf(25)
ta list self._data_lst contient ça
[['0', '0', '0'], [100, '0', '0'], [80, 20, 20], [150, 10, 2]]
Donc si tu ne veux pas avoir ces petit soucie des type mutable je te conseil de regarde le module copy
Sinon ton algorithme me semble pas trop pythonique

[eyquem]

Moi par contre, j’adore analyser des codes quand j’ai le temps. Ça me délasse

Bon, je réagis à mesure que je lis ton code.



Il y a plusieurs choses qui ne vont pas dans
def _lst_index_elm_list (self,elmt, liste):



1) Dans while data2.count(elmt) !=0 :
count() compte tous les elmt dans data2 pour savoir s’il en reste dans la liste data2, et pour ce faire, count() est obligé de parcourir l’intégralité de la liste jusqu’au dernier élément.
Ceci à chaque tour de while.
Sachant qu’ensuite, c’est index() qui reparcourt une portion plus ou moins longue de la liste pour trouver où se trouve le premier elmt dans la liste.
Tout cela est beaucoup de travail, redondant.

Alors qu’il suffit de savoir s’il en reste au moins un ou pas du tout.
Ce qui s’établit plus simplement par un test dont l’exécution est beaucoup plus rapide que celle de count():

Code :

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

while elmt in data2:

Mais réitérer ce test continuellement n’est pas encore la meilleure solution. Car même s’il est plus rapide, il reste que ce test et index() parcourent toujours plusieurs fois la liste.

Il faut chercher à ne la parcourir qu’une fois.



2) Quand data2.index(elmt) est exécutée, la fonction index() fait sa recherche en commençant par le début de la liste data2.

Ce qui veut dire qu’à chaque nouvelle liste data2 ( issue de la précedente par élimination du premier elmt qui avait été précédemment rencontré par index() ), la fonction index() reparcourt le début de data2:
- elle parcourt donc plusieurs fois les mêmes élements de data2
- elles les parcourt alors qu’il n’y a plus de elmt parmi eux, puisqu’ils sont au fur et à mesure enlevés

Par dessus le marché, index() est assez lente à se mouvoir dans une liste.

Donc algorithme pas bon.



Une solution de courte-vue:

il ne faut pas jeter id1, il faut l’utiliser comme repère pour redémarrer l’analyse de data2 par index() . Mais attention, le fait d’enlever un élément de data2 décale de -1 les valeurs des index des éléments suivants. Donc il faut être finaud.
Mais c’est un remède très médiocre.




Ce qui ne va pas basiquement pas dans le code de cette fonction, c’est que index() itère sur les éléments de la liste, dit la position de l’élément recherché, et s’arrête.

Ce qui conduit à enlever un élément une fois que la détection a eu lieu pour chercher le suivant. Ce qui conduit encore à créer un double, data2, de la liste originale pour ne pas l’altérer.

Quand on s’enfonce comme ça dans des contorsions en cascade, c’est qu’il y a un truc qui ne va pas. Parfois, ça sert de se dire: et si je faisais l’inverse ?

OK, allons-y: itérons non plus sur les éléments de la liste mais sur les positions. Et détectons donc quand l’élément à la position examinée est égal à celui voulu. Et paf ça donne:

Code :

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

1
2
3
4
5
6
    def _lst_index_elm_list (self,elmt, liste):
        lst_index =[]
        for i in xrange(len(liste)):
            if liste[i]==elmt:
                lst_index.append(i)
        return lst_index

3) Il y a encore mieux à faire en recourant à une list comprehension:

Code :

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

1
2
    def _lst_index_elm_list (self,elmt, liste):
        return [ i for i in xrange(len(liste)) if liste[i]==elmt ]

4) Quand tu écris data2 = liste , cela ne crée pas une seconde liste identique et indépendante de la première.

Cela crée une étiquette ’data2’ qui est collée à l’objet liste qui portait déjà comme étiquette le nom ’liste’: il s’agit d’aliasing sur un même objet, et non pas d’une duplication d’objet.

Ce qui entraîne que toute modification ciblée vers data2 atteint en réalité le seul objet ayant les deux noms ’data2’ et ’liste’.

[Tyrus]

Je propose ça

Code :

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

1
2
3
4
5
6
>>> data = [ [50,25,50],[100,25,25],[80,20,20],[150,10,2] ]
>>> list = []
>>> [ list.extend([(index1,index2) for index2,item2 in enumerate(item1) if item2 == 25]) for index1,item1 in enumerate(data)] 
[None, None, None, None]
>>> list
[(0, 1), (1, 1), (1, 2)]

Même si j'aime pas le list.extend dans la liste compréhension mais j'ai pas en tête une fonction pour sommer des listes :/

edit un truc un peu plus jolie

Code :

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

1
2
3
4
>>> def extend_plus(a,b): 
...     a.extend(b)
...     return a 
reduce(extend_plus, [ list.extend([(index1,index2) for index2,item2 in enumerate(item1) if item2 == 25]) for index1,item1 in enumerate(data)] ,[])

[leau2001]

Merci à tous pour vos remarques constructives... j'ai bien conscience que mon code est très loin d'etre optimisé... en fait c'est le premier jet... je fais toujours un premier code qui fonctionne et ensuite j'essaye de l'améliorer...

Dans ce cas là, il ne fonctionnait pas... JE vais regarder avec toutes vos remarques et revenir vers vous lorsque j'aurai fait tourner tout ça...

Merci à toutes et tous

lo