Discussion :

[Zavonen]

Bonjour tout le monde !
Je voudrais savoir comment en Python réaliser l'équivalent des classes 'template' de C++. J'ai cherché demandé à notre ami Google 'Python template' mais les réponses n'ont apparemment rien à voir avec les classes paramétrées.
Je vais donner un exemple.
Je veux modéliser les corps Z/pZ pour p premier d'un seul coup.
Je sais modéliser Z/2Z, Z/3/Z, Z/5Z.
Je sais aussi utiliser une variable globale p au niveau du fichier d'implémentation de la classe Z/pZ mais ça c'est vraiment 'quick and dirty', si je veux faire des calculs simultanément dans Z/2Z et Z/3Z vous voyez le problème ...
Quelqu'un a une idée plus 'clean' ?

[Pragmateek]

Et pourquoi ne pas passer "p" en tant que paramètre du constructeur de la classe représentant ces ensembles ?

[Zavonen]

Parce que dans la même classe tu vas avoir des instances de Z/2Z et de Z/3Z, je sais multiplier entre eux des éléments de Z/2Z ou de Z/3Z mais le produit d'un élément de Z/2Z par un autre de Z/3Z c'est quoi ???

[Pragmateek]

Après un petit tour sur wiki ... le problème est que la loi multiplicative est une loi de composition interne à la structure d'anneau ?
Et donc le produit Z/2Z * Z/3Z n'est pas défini ?

Si c'est bien ça, il reste possible de vérifier que l'opération a un sens au sein de l'opérateur utilisé en comparant la valeur du paramètre "p" des deux instances constituant les deux opérandes de l'opérateur "*".
Si elle n'en a pas il suffit de lever une exception ou renvoyer "None".

[Zavonen]

Merci, mais en tant qu'algébriste je connais tout ça.

Après un petit tour sur wiki ... le problème est que la loi multiplicative est une loi de composition interne à la structure d'anneau ?
Et donc le produit Z/2Z * Z/3Z n'est pas défini

Au passage le produit Z/2Z * Z/3Z est parfaitement défini, ce qui n'est pas défini c'est le produit d'un élément de Z/2Z par un élément de Z/3Z
Mon problème n'est pas mathématique...
Je n'ai donné ceci que comme exemple.
Mon problème est comment crée-t-on des classes paramétrées en Python ?

[Antoine_935]

Salut

Python n'offre pas de construction similaire au templates du C++ ou generics de Java, car il n'en a pas besoin.

On peut virtuellement passer n'importe quel type d'argument à une fonction. C'est à la fonction de réagir en selon le type.

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
>>> class Z1: pass
... 
>>> class Z2: pass
... 
>>> def test(arg):
...     if isinstance(arg, Z1):
...         print("C'est un Z1")
...     elif isinstance(arg, Z2):
...         print("C'est un Z2")
... 
>>> z1 = Z1()
>>> z2 = Z2()
>>> test(z1)
C'est un Z1
>>> test(z2)
C'est un Z2

Vois aussi les méthodes type et issubclass.

Mais il y a mieux que la méthode ci-dessus, quand tu peux utiliser la surcharge des opérateurs:

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
>>> class Z1:
...     def __init__(self, val):
...         self.__val = val
...     def __div__(self, divider):
...         return self.__val / divider
... 
>>> class Z2:
...     def __init__(self, val):
...         self.__val = val
...     def __div__(self, divider):
...         return (self.__val / divider) * 2
... 
>>> z1 = Z1(20)
>>> z2 = Z2(20)
>>> def test(arg):
...     return arg / 4
... 
>>> test(z1)
5
>>> test(z2)
10

Mais si tu cherches une solution pour implémenter ces templates avec l'API C de Python, il te suffit de réadapter la solution ci-dessus au C.

[Zavonen]

Merci Antoine, mais rien de tout cela n'est nouveau pour moi et cela ne résout pas mon problème.
Python n'a peut-être pas besoin de classes paramétrées mais moi j'en ai besoin.
recadrons le débat:
Je peux faire une classe C2 modélisant Z/2P
class C2(object):
def __init__(self,m):
self.n=m%2
def __mul__(self, other):
return C2(self.n*other.n/2)

etc, etc....
Bon maintenant, si je veux définir la classe C3 je remplace 2 par 3 et ainsi de suite pour p=5,7,11. C'est crétin.
Je devrais pouvoir définir toutes les classes Cp avec un paramètre p en une fois.

[shadowsam]

Alors je ne suis pas sur que cela soit bien propre ce que je vais te proposer, mais j'ai pensé a quelque chose.

Si au lieu de penser a n declaration de class on pense a une declaration de calss générique, on s'approche de la solution.
Et donc si on veut faire cela, il suffirait de mettre cette declaration de class dans une fonction a 1 paramettre. ce paramettre etant le "paramettre de class"

Voila comment je vois les choses:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
def gen_class(name, param):
    class generique_X(object):
        def __init__(self, x):
            self._x = x
        def fonction(x):
            return self._x%param
 
    setattr(__dict__, name+str(param), generique_X)
 
gen_class(Z, 1)
gen_class(Z, 2)
gen_class(Z, 3)

Je n'ai pas vraiment tester ce code, donc ca ne marche peut être directement en l'état. Mais voila à quoi je pensais. Il y surement des limitation a ce que l'on peut faire avec cette méthode, mais déjà ca permet de faire un certain nombre de choses.

[Zavonen]

@Shadowsam
Ta proposition a l'air sympa.
Je vais essayer cela en soirée et je te tiens au courant mais je crois bien que ça va marcher.

[Antoine_935]

Bon maintenant, si je veux définir la classe C3 je remplace 2 par 3 et ainsi de suite pour p=5,7,11. C'est crétin.
Je devrais pouvoir définir toutes les classes Cp avec un paramètre p en une fois.

C'est la première chose à laquelle j'aie pensé, mais je ne vois pas l'utilité d'une classe par diviseur. J'ai peut-être raté un élément primordial à ce besoin, mais est-ce que ce ne serait pas plus simple comme suit ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
>>> class Z:
...     def __init__(self, facteur, m):
...         self.facteur = facteur
...         self.n = m % facteur
...     
...     def __mul__(self, other):
...         return Z(self.facteur, self.n * other.n / self.facteur)
... 
>>> z2 = Z(2, 6)
>>> z3 = Z(3, 6)
>>> z2 * z3
<__main__.Z instance at 0xb7cf412c>

Mais sauf erreur de ma part, les templates C++ ne permettent pas de donner des valeurs en paramètres, mais seulement des types. Enfin, je me trompe peut-être, et je serais intéressé par un lien

[shadowsam]

J'aurais un peu tendance a rejoindre Antoine.

J'ai pensé un truc qui répond à ce que tu demandes, mais honnêtement je ne comprends pas trop le pourquoi du comment.

[Zavonen]

@Antoine,
C'est mieux mais j'y avais pensé, le problème est que c'est la même classe et qu'on peut a priori multiplier des congruences modulo des p distincts, ce qui n'a pas de sens mathématique.
Je crois que je vais me rabattre sur la proposition de shadowsam que j'ai testée et qui fonctionne:

Code python :

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
def GenClasse(p):
    class C(object):
        carac=p
        def __init__(self,x):
            self.z=x%C.carac
        def __str__(self):
            return str(self.z)
        def __mul__(self,other):
            return C((self.z*other.z)%C.carac)
    return C
 
Z2=GenClasse(2)
Z3=GenClasse(3)
z2=Z2(3)
z3=Z3(2)
print z2
print z3
print z2*z2
print z3*z3

Pour les templates en C++ j'en fait une utilisation abondante dans un ressource du forum algo intitulée 'Polynômes à plusieurs variables à coefficients dans un corps quelconque' (sous-forum 'contribuez'), tu peux jeter un coup d'oeil, mais rien ne vaut la doc officielle de Soustrup.

[Pragmateek]

Merci, mais en tant qu'algébriste je connais tout ça.

C'était juste pour être sûr de la problématique.

Au passage le produit Z/2Z * Z/3Z est parfaitement défini, ce qui n'est pas défini c'est le produit d'un élément de Z/2Z par un élément de Z/3Z

Oui, bien sûr, la formulation était mal choisie.

les templates C++ ne permettent pas de donner des valeurs en paramètres, mais seulement des types

Si et c'est d'ailleurs sur cette fonctionnalité qu'est basée une partie de la métaprogrammation C++ : http://loulou.developpez.com/tutoriels/cpp/metaprog/

[Antoine_935]

Si et c'est d'ailleurs sur cette fonctionnalité qu'est basée une partie de la métaprogrammation C++ : http://loulou.developpez.com/tutoriels/cpp/metaprog/

Oh merci pour le lien ! Je viens de survoler, ça a l'air intéressant. J'aurai plus de temps pour lire ça demain.