Creation d'un classe pour incrémenter une liste

Version imprimable

Bonjour

Voila je souhaite incrémenter les valeurs d'une liste. Pour ce faire j'ai fait une boucle et celà fonctionne très bien.
Code:

1 2 3 4 5 list=[1,2,3,4,5,6,7,8,9] for i in range(0,len(list)): list[i]=list[i]+1 print list
Jusqu'ici rien de très compliqué.

Maintenant j'aimerai allez plus loin. Plutôt qu'à chaque fois de passer par une boucle pour incrémenter les termes d'une liste je souhaiterai passer par une classe (dans laquelle sera définit ma boucle) afin de pouvoir écrire dans mon programme principal ce qui suit :
Code:

1 2 3 4 5 6 7 8 import incrementation .... .... .... list=[1,2,3,4,5,6,7,8,9] # définition de la liste list.inrementation (1) # appel de la classe incrémentation pour incrémenter chaque terme de la liste
Entre les parenthèse je souhaite pourvoir indiquer le pas de l'incrémentation.

Voilà ce que j'ai essayé de pondre en lisant quelques tutos mais bon vous l'aurez compris ça ne fonctionne pas.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 class incrementation: def __init__(self,list,pas): self.list=[] self.i=0 self.pas=0 def increment(self,pas): for i in range(0,len(list)): list[i]=list[i]+pas A=[1,2,3,4,5,6,7,8,9] A.incrementation(1) print A
L'erreur que j'obtient est la suivante :
Code:

1 2 3 4 5 Traceback (most recent call last): File "D:/PYTHON/__Class__/test_class_increment.py", line 13, in <module> A.incrementation(1) AttributeError: 'list' object has no attribute 'incrementation'
Une idée ?

Merci d'avance

Salut,

Dans ton exemple, A est une instance de list() donc lorsque tu fais A.incrementation() tu appelles l'attribut (dans ce cas ci une méthode) incrementation de cette instance de classe. Et le message d'erreur te dit que cet attribut n'existe pas.

Une classe s'utilise par instance interposée, ce qui veux dire que tu peux faire:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class incrementation: def __init__(self, list_, pas): self.list = list_ self.pas = pas def increment(self): return [i + self.pas for i in self.list] # A est une liste A=[1,2,3,4,5,6,7,8,9] # inc est une instance de incrementation inc = incrementation(A, 1) print inc.increment()
J'ai changé le code de ta classe qui comportait quelques erreurs.

Citation:
Envoyé par VinsS
Salut,

Dans ton exemple, A est une instance de list() donc lorsque tu fais A.incrementation() tu appelles l'attribut (dans ce cas ci une méthode) incrementation de cette instance de classe. Et le message d'erreur te dit que cet attribut n'existe pas.

Une classe s'utilise par instance interposée, ce qui veux dire que tu peux faire:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class incrementation: def __init__(self, list_, pas): self.list = list_ self.pas = pas def increment(self): return [i + self.pas for i in self.list] # A est une liste A=[1,2,3,4,5,6,7,8,9] # inc est une instance de incrementation inc = incrementation(A, 1) print inc.increment()
J'ai changé le code de ta classe qui comportait quelques erreurs.
Voilà justement c'est ça que je n'ai pas bien compris.

pourquoi être obligé de définir toto=NonDeLaClasse() pour ensuite faire toto.increment() ?
pourquoi ne pas pouvoir faire MaList.incremantion(1) directement ?

Le fait de passer par toto me bloque :calim2:

Merci ça fonctionne mais je veux vraiment essayé de comprendre.

Citation:

Envoyé par nekcorp

Voilà justement c'est ça que je n'ai pas bien compris.

pourquoi être obligé de définir toto=NonDeLaClasse() pour ensuite faire toto.increment() ?
pourquoi ne pas pouvoir faire MaList.incremantion(1) directement ?

Le fait de passer par toto me bloque :calim2:

Merci ça fonctionne mais je veux vraiment essayé de comprendre.

Bonsoir,
"MaList.incremantion(1)"
Ici, MaList est de type "<class 'list'>"
"dir(MaList)" dans le schell indique l'ensemble des méthodes applicables à la classe et donc à l'instance (MaList)!

Et incremantion n'existe pas…
Il faut donc créer une nouvelle classe soit en surchargeant la classe "list" existante, soit en créant une classe qui fait juste ce que vous voulez faire.

Voilà!!

Clodion

PS: help(lst) donne aussi beaucoup de renseignements avec des explications!!

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
>>> lst=[1,2,3,4,5,6,7,8,9]
>>> dir(lst)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> help(lst)
Help on list object:
 
class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable's items
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(...)
 |      __ge__=($self, value, /)
 |      --
 |      
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      L.__reversed__() -- return a reverse iterator over the list
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      L.__sizeof__() -- size of L in memory, in bytes
 |  
 |  append(...)
 |      L.append(object) -> None -- append object to end
 |  
 |  clear(...)
 |      L.clear() -> None -- remove all items from L
 |  
 |  copy(...)
 |      L.copy() -> list -- a shallow copy of L
 |  
 |  count(...)
 |      L.count(value) -> integer -- return number of occurrences of value
 |  
 |  extend(...)
 |      L.extend(iterable) -> None -- extend list by appending elements from the iterable
 |  
 |  index(...)
 |      L.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
 |  
 |  insert(...)
 |      L.insert(index, object) -- insert object before index
 |  
 |  pop(...)
 |      L.pop([index]) -> item -- remove and return item at index (default last).
 |      Raises IndexError if list is empty or index is out of range.
 |  
 |  remove(...)
 |      L.remove(value) -> None -- remove first occurrence of value.
 |      Raises ValueError if the value is not present.
 |  
 |  reverse(...)
 |      L.reverse() -- reverse *IN PLACE*
 |  
 |  sort(...)
 |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
 
>>>

Citation:
Envoyé par nekcorp
Bonjour

Voila je souhaite incrémenter les valeurs d'une liste. Pour ce faire j'ai fait une boucle et celà fonctionne très bien.
Code:

1 2 3 4 5 list=[1,2,3,4,5,6,7,8,9] for i in range(0,len(list)): list[i]=list[i]+1 print list
Jusqu'ici rien de très compliqué.

Maintenant j'aimerai allez plus loin. Plutôt qu'à chaque fois de passer par une boucle pour incrémenter les termes d'une liste je souhaiterai passer par une classe (dans laquelle sera définit ma boucle) afin de pouvoir écrire dans mon programme principal ce qui suit :
(snip)(snip)
Une idée ?

Merci d'avance
Bonjour,

Une question en passant par là : pourquoi forcément une classe ?

une fonction tout ce qu'il y a de plus simple ne suffirait-elle pas à résoudre ce problème ?

Exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #!/usr/bin/env python3 # -*- coding: utf-8 -*- def increment (num_list, step=1): return [n + step for n in num_list] # end def ma_liste = list(range(1, 10)) # pareil que [1,2,3,...9] print("liste d'origine:", ma_liste) print("incrément avec un pas de 1:", increment(ma_liste)) print("incrément avec un pas de 3:", increment(ma_liste, 3)) # si vous voulez conserver votre liste mise à jour ma_liste = increment(ma_liste) print("liste mise à jour (incrément de 1):", ma_liste)
Une classe est avant tout une structure qui regroupe des propriétés et des comportements (membres, méthodes, attributs).

À quoi bon sortir l'artillerie lourde pour dégommer un moucheron ? :mrgreen:

Une simple fonction suffit amplement... non ?

@+.

Citation:

Envoyé par Clodion

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
>>> lst=[1,2,3,4,5,6,7,8,9]
>>> dir(lst)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> help(lst)
Help on list object:
 
class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable's items
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(...)
 |      __ge__=($self, value, /)
 |      --
 |      
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      L.__reversed__() -- return a reverse iterator over the list
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      L.__sizeof__() -- size of L in memory, in bytes
 |  
 |  append(...)
 |      L.append(object) -> None -- append object to end
 |  
 |  clear(...)
 |      L.clear() -> None -- remove all items from L
 |  
 |  copy(...)
 |      L.copy() -> list -- a shallow copy of L
 |  
 |  count(...)
 |      L.count(value) -> integer -- return number of occurrences of value
 |  
 |  extend(...)
 |      L.extend(iterable) -> None -- extend list by appending elements from the iterable
 |  
 |  index(...)
 |      L.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
 |  
 |  insert(...)
 |      L.insert(index, object) -- insert object before index
 |  
 |  pop(...)
 |      L.pop([index]) -> item -- remove and return item at index (default last).
 |      Raises IndexError if list is empty or index is out of range.
 |  
 |  remove(...)
 |      L.remove(value) -> None -- remove first occurrence of value.
 |      Raises ValueError if the value is not present.
 |  
 |  reverse(...)
 |      L.reverse() -- reverse *IN PLACE*
 |  
 |  sort(...)
 |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None
 
>>>

Merci de cette réponse je commence à mieux comprendre. En fait je me créé un dossier dans lequel je met des fonctions et des classes que j'utilise souvent dans mon programme.

Lorsque tu dis "surcharger la classe list" tu veux dire modifier le fichier source de l'instance "list" et donc ajouter une méthode c'est bien ça ?

Citation:
Envoyé par tarball69
Bonjour,

Une question en passant par là : pourquoi forcément une classe ?

une fonction tout ce qu'il y a de plus simple ne suffirait-elle pas à résoudre ce problème ?

Exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #!/usr/bin/env python3 # -*- coding: utf-8 -*- def increment (num_list, step=1): return [n + step for n in num_list] # end def ma_liste = list(range(1, 10)) # pareil que [1,2,3,...9] print("liste d'origine:", ma_liste) print("incrément avec un pas de 1:", increment(ma_liste)) print("incrément avec un pas de 3:", increment(ma_liste, 3)) # si vous voulez conserver votre liste mise à jour ma_liste = increment(ma_liste) print("liste mise à jour (incrément de 1):", ma_liste)
Une classe est avant tout une structure qui regroupe des propriétés et des comportements (membres, méthodes, attributs).

À quoi bon sortir l'artillerie lourde pour dégommer un moucheron ? :mrgreen:

Une simple fonction suffit amplement... non ?

@+.
En fait ce qui m’intéresse avec les classes c'est la manière dont elles sont appelées. C'est la manière dont je vais l'écrire, l'appeler dans mon programme principal qui m’intéresse.

Pour faire simple lorsque vous voulez ajouter un terme à une liste, vous l'écrivez comme ceci :
Code:

1 2 Maliste.append(valeuraajouter)
je veux donc que ma classe increment fonctionne aussi simplement :
Code:

1 2 Maliste.increment(valeurdincrement)
Est ce que vous comprenez ce que je souhaite faire ou toujours pas ? :roll:

en tout cas merci de vous intéresser à mon problème.

Citation:
Envoyé par nekcorp
En fait ce qui m’intéresse avec les classes c'est la manière dont elles sont appelées. C'est la manière dont je vais l'écrire, l'appeler dans mon programme principal qui m’intéresse.

Pour faire simple lorsque vous voulez ajouter un terme à une liste, vous l'écrivez comme ceci :
Code:

1 2 Maliste.append(valeuraajouter)
je veux donc que ma classe increment fonctionne aussi simplement :
Code:

1 2 Maliste.increment(valeurdincrement)
Est ce que vous comprenez ce que je souhaite faire ou toujours pas ? :roll:

en tout cas merci de vous intéresser à mon problème.
Oui, oui, j'avais compris. :mrgreen:

Je trouvais juste cette fonctionnalité un peu superflue, mais effectivement, si vous voulez "augmenter" les capacités d'une liste Python, vous pouvez recourir à un mécanisme original : l'auto-surcharge d'une classe par ELLE-MÊME.

Regardez :
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 #!/usr/bin/env python3 # -*- coding: utf-8 -*- # avec Python, ON A LE DROIT de dériver une classe par ELLE-MÊME (!) class list (list): # nouvelle fonctionnalité def increment (self, step=1): # incrémentation dite "in-place" for i, n in enumerate(self): # in-place op self[i] = n + step # end for # pour enchaîner les fonctionnalités entre elles: return self # end def # end class # ============================ DEMO ================================ # ATTENTION: petite subtilité /!\ # si j'utilise maintenant l'objet list() Python, ça marche: ma_liste = list(range(1, 10)) print("ma_liste originale :", ma_liste, type(ma_liste)) print("incrémentation de ma_liste d'un pas de 3 :", ma_liste.increment(3)) print() # en revanche, si j'utilise un objet [] (liste NATIVE Python) # ÇA NE MARCHERA PAS: ma_liste = [1,2,3,4,5,6,7,8,9] print("ma_liste originale :", ma_liste, type(ma_liste)) # essai try: print("incrémentation de ma_liste d'un pas de 3 :", ma_liste.increment(3)) except: print("Aïe! l'objet est NATIF! Ça ne marche pas!") # end try
On peut surcharger une classe native Python (comme on peut surcharger n'importe quelle classe par ELLE-MÊME, d'ailleurs), mais dans le cas d'une classe native Python, cela reste limité aux constructeurs de classes classiques e.g. mon_objet = MaClasse() et NON PAS mon_objet = [1,2,3] # natif.

@+.

Salut

Citation:

Envoyé par tarball69

l'auto-surcharge d'une classe par ELLE-MÊME.
...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
class list (list):
    # nouvelle fonctionnalité
    def increment (self, step=1):
        # incrémentation dite "in-place"
        for i, n in enumerate(self):
            # in-place op
            self[i] = n + step
        # end for
        # pour enchaîner les fonctionnalités entre elles:
        return self
    # end def
# end class

En toute rigueur, c'est inexact. On crée un nouvelle classe list. C'est d'ailleurs pour cela qu'on ne peut plus utiliser l'écriture [ ... ] pour cette nouvelle classe.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
MacBookAir:~ plxpy$ python
Python 2.7.8 (v2.7.8:ee879c0ffa11, Jun 29 2014, 21:07:35) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> id(list)
4296525216
>>> class list(list):
...     def new_method(self):
...             pass
... 
>>> id(list)
4300211712
>>> 
>>> L = list()
>>> L.new_method()
>>> 
>>> L = []
>>> L.new_method()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'list' object has no attribute 'new_method'
>>>

La list "canal historique" existe toujours et ne connait pas la nouvelle méthode :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
>>> id(__builtins__.list)
4296525216
>>> 
>>> liste = []
>>> isinstance(liste, list)
False
>>> isinstance(liste, __builtins__.list)
True
>>> liste.new_method()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'list' object has no attribute 'new_method'

Mais, je suis d'accord, c'est du détail.

13/02/2015, 13h40
Invité
Citation:

Envoyé par plxpy

Salut
En toute rigueur, c'est inexact. On crée un nouvelle classe list. C'est d'ailleurs pour cela qu'on ne peut plus utiliser l'écriture [ ... ] pour cette nouvelle classe.

Absolument. Et c'est d'ailleurs une pratique peu pertinente que de recourir à ce genre de dérivation (car apporte de la confusion à la relecture du code).

Il est toujours préférable de distinguer les classes dérivées :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #!/usr/bin/env python3 # -*- coding: utf-8 -*- class xList (list): def blablabla (self): pass # etc # end def # end class ma_liste = xList(range(1,10)) # etc...
@+.