Creation d'un classe pour incrémenter une liste

**nekcorp** · 12/02/2015, 15h36

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 :

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

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 :

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

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 :

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

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

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

**VinsS** · 12/02/2015, 15h58

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 :

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

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.

**nekcorp** · 12/02/2015, 16h05

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 :

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

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

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

**Clodion** · 12/02/2015, 17h01

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

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 :

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

Invité · 12/02/2015, 18h34

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 :

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

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 :

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
#!/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 ?

Une simple fonction suffit amplement... non ?

@+.

**nekcorp** · 13/02/2015, 11h39

Envoyé par Clodion

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 :

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

**nekcorp** · 13/02/2015, 11h47

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 :

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
#!/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 ?

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 :

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

1
2
 
Maliste.append(valeuraajouter)

je veux donc que ma classe increment fonctionne aussi simplement :

Code :

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

1
2
 
Maliste.increment(valeurdincrement)

Est ce que vous comprenez ce que je souhaite faire ou toujours pas ?

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

Invité · 13/02/2015, 12h23

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 :

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

1
2
 
Maliste.append(valeuraajouter)

je veux donc que ma classe increment fonctionne aussi simplement :

Code :

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

1
2
 
Maliste.increment(valeurdincrement)

Est ce que vous comprenez ce que je souhaite faire ou toujours pas ?

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

Oui, oui, j'avais compris.

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 :

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
#!/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.

@+.

**plxpy** · 13/02/2015, 13h34

Salut

Envoyé par tarball69

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

Code :

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

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 :

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

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

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.

Invité · 13/02/2015, 13h40

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 :

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

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

@+.

Creation d'un classe pour incrémenter une liste

Python

Discussions similaires

Partager

Partager