Utiliser deux classes pour pouvoir créer une fonction

Version imprimable

Bonjour à tous,

j'ai un petit exercice en python mais je n'arrive pas à le réaliser.
Je veux utiliser deux classes pour pouvoir créer une fonction (ma fonction qui est un calcul mathématique), mais je ne sais pas comment faire.
Je vous montre un exemple
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class 1() : def __init__ (self, a, b, c, d, e): self.a= a self.b= b self.c= c self.d= d self.e= e class 2(): def __init__ (self, x, y, z): self.x= x self.y= y self.z= z
et maintenant dans une class Calcul() je veux implémenter ma formule en faisant la chose suivante :
Code:

1 2 3 4 5 def w(self): if self.d == 0 return b elif self.d == 1 return x + b
Merci pour votre aide

14/10/2021, 11h12
wiztricks

Salut,

Ce que vous cherchez à faire n'est pas très clair (la question non plus!).
Peut être que vous devriez commencer par faire çà sans classe.... çà permettrait de montrer quelque chose qui marche et un point de départ.

- W
14/10/2021, 11h16
abc_def

Hey,

En fait je veux simplement utiliser deux classes pour pouvoir faire mon calcul.
Je n'ai pas compris comment faire si je veux avoir un résultat sans utiliser de classe
14/10/2021, 11h22
wiztricks

Citation:

Envoyé par abc_def

En fait je veux simplement utiliser deux classes pour pouvoir faire mon calcul

Et je vous ai suggéré de commencer à réaliser cela "sans".
Après si vous ne savez pas vous y prendre avec les "class", il faudrait voir le problème que vous avez... (ce qui suppose que vous avez essayé quelque chose) ou ouvrir un tuto. au chapitre qui parle des class.

- W
14/10/2021, 11h26
abc_def

Pourriez-vous m'indiquer comme je pourrai faire sans class dans ce cas et obtenir un résultat svp.
Car le calcul que je veux effectuer possède un élément des deux classes comme dans l'exemple montré ci-dessus

Merci à vous
14/10/2021, 11h54
Sve@r

Bonjour

Citation:

Envoyé par abc_def

Pourriez-vous m'indiquer comme je pourrai faire sans class dans ce cas et obtenir un résultat svp.

Il faudrait d'abord que tu explicites avec des phrases simples quel calcul tu veux faire. Me semble que tu nous fais là un cas de problème XY.

Citation:

Envoyé par abc_def

Car le calcul que je veux effectuer possède un élément des deux classes comme dans l'exemple montré ci-dessus

Pas possible, les éléments d'une classe sont toujours distincts. Ce n'est pas parce qu'une classe X possède un attribut "toto" et qu'une classe Y possède aussi un attribut "toto" que ce sont les mêmes attributs. Prend par exemple une classe "carre" et une classe "rectangle", toutes deux possèderont à priori un attribut "longueur" mais ils n'auront pas la même signification pour l'un et pour l'autre.
14/10/2021, 12h03
wiztricks

Citation:

Envoyé par abc_def

Pourriez-vous m'indiquer comme je pourrai faire sans class dans ce cas et obtenir un résultat svp.
Car le calcul que je veux effectuer possède un élément des deux classes comme dans l'exemple montré ci-dessus

Un calcul se fait avec des nombres: scalaires, vecteurs, ou tableaux.
Représenter un vecteur avec une liste, un tuple ou une "class" ne change pas grand chose au résultat.

- W
14/10/2021, 12h22
Arioch
Pour le boulot, j'ai déjà souvent eu à faire une classe dont certains de ses attributs étaient des instances d'autres classes.
Code:

1 2 3 class FooBar: self.attr1 = instance classe 1 self.attr2 = instance classe 2
Pour travailler avec les attributs 'a' des classes 1 et 2 depuis la classe ci-dessus :
Code:

1 2 self.attr1.a self.attr2.a
Maintenant, pour votre besoin, sans plus de détails sur ce que vous voulez, c'est difficile.

Bon, je ne suis qu'un novice en python mais je fais de la POO depuis longtemps.
De ce que je vois, tu n'a pas compris le principe d'encapsulation.
Pour résoudre ton problème, il faut que ta classe calcul connaisse les membres dont il fait appel
- soit en lui fournissant directement ces membres
- soit en lui fournissant des objets qui contiennent ces membres et en passant par eux
- soit en héritant des classes qui ont ces membres

D'autres pourront compléter ou corriger mon code mais voici déjà 4 façon de procéder :

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
class Foo1():
 
    def __init__(self, a, b, c, d, e):
        self.a = a
        self.b = b
        self.c = c
        self.d = d
        self.e = e
 
 
class Foo2():
 
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
 
 
class Calcul1(object):
    def __init__(self, Foo1, Foo2):
        self.a = Foo1.a
        self.b = Foo1.b
        self.c = Foo1.c
        self.d = Foo1.d
        self.e = Foo1.e
        self.x = Foo2.x
        self.y = Foo2.y
        self.z = Foo2.z
 
    def w(self):
        if self.d == 0:
            return self.b
        elif self.d == 1:
            return self.x + self.b
 
class Calcul2(object):
    def __init__(self, foo1, foo2):
        self.foo1 = foo1
        self.foo2 = foo2
 
    def w(self):
        if self.foo1.d == 0:
            return self.foo1.b
        elif self.foo1.d == 1:
            return self.foo2.x + self.foo1.b
 
class Calcul3(object):
 
    def w(self, foo1, foo2):
        if foo1.d == 0:
            return foo1.b
        elif foo1.d == 1:
            return foo2.x + foo1.b
 
 
class Calcul4(Foo1, Foo2):
    def __init__(self, a, b, c, d, e, x, y, z):
        Foo1.__init__(self, a, b, c, d, e)
        Foo2.__init__(self, x, y, z)
 
    def w(self):
        if self.d == 0:
            return self.b
        elif self.d == 1:
            return self.x + self.b
 
 
foo1 = Foo1(0, 1, 0, 1, 0)
foo2 = Foo2(1, 0, 1)
 
calcul1 = Calcul1(foo1, foo2)
calcul2 = Calcul2(foo1, foo2)
calcul3 = Calcul3()
calcul4 = Calcul4(0, 1, 0, 1, 0, 1, 0, 1)
print(calcul1.w())
print(calcul2.w())
print(calcul3.w(foo1, foo2))
print(calcul4.w())

15/10/2021, 13h50
Sve@r

Citation:

Envoyé par popo

mais voici déjà 4 façon de procéder

J'aime bien la seconde méthode. C'est celle qui se rapproche le plus de ce que je ferais (gaffe tout de même que si Foo1 ou Foo2 ont des attributs privés, ce sera peaudec... pour faire le calcul)
Mais je mets +1 parce que grace à toi j'ai enfin compris ce qu'il voulait faire (sans déconner, si ce qui se conçoit bien s'énonce clairement, manifestement il ne conçoit vraiment pas bien les choses !!! :roll:)

ça fait beaucoup de lignes pour juste faire:

Code:

1
2
3
4
5
6
7
8
9
10
11
def calcul1(a,b,c,d,e, x, y, z):
    return b if d == 0 else x + b
 
def calcul2(u, v):
    return calcul1(*(u + v)) 
 
foo1 = 0, 1, 0, 1, 0
foo2 = 1, 0, 1
 
print(calcul1 (*(foo1 + foo2)))
print(calcul2(foo1, foo2))

- W

15/10/2021, 21h19
popo

Certes, il y a plus de lignes mais ça passe par ses classes, comme demandé.

Par contre, "(*(u+v))" et "b = if..."
Décidément, plus je découvre python, et plus la syntaxe me fait tiquer. Je n'ose même pas imaginer la complexité de l'interpréteur.

Citation:

Envoyé par popo

Par contre, "(*(u+v))" et "b = if..."

*(u+v) effectivement ça pique. Ca fait appel à l'unpacking
Prenons une fonction à 2 paramètres, exemple: def somme(a, b): return a+b. Si de ton côté tu as un tuple de deux éléments (x=(1, 2)), tu peux passer chaque élement du tuple à la fonction (somme(x[0], x[1])) ou passer directement le tuple en demandant à Python de le décomposer pour toi via l'unpacking => somme(*x).
Et ça marche aussi si tu as un dictionnaire dont les clefs sont les noms des paramètres, mais là avec alors deux étoiles => x={"a" : 1, "b" : 2}; somme(**x).
C'est en quelque sorte l'opération inverse du "*args" et "**kwargs" des paramètres de fonctions (qui, eux, récupèrent en un coup tout ce qui n'a pas été récupéré avant => packing)

Personnellement je m'en sers quand je veux automatiser un même traitement sur des données disparates (comme par exemple provenant d'une requête SQL) et présenter chaque donnée dans un tableau IHM (ex QTableWidget de Qt).
Sauf que les données revenues de ma requête SQL ne sont pas toutes de même nature. Je peux avoir un nom+prénom (2 items), un age (un item) et un montant (un item).

Exemple: data=(("toto", "titi"), (18,), (12500.0,)).

Une première solution est de gérer la colonne et faire un traitement en conséquence
Code:

1 2 3 4 5 6 7 8 9 10 data=(("toto", "titi"), (18,), (12500.0,)) for (i, d) in enumerate(data): if i == 0: print("Nom : %s, prenom: %s" % (d[0], d[1])) elif i == 1: print("Age : %d" % d[0]) else: print("Montant: %.2f€" % d[0]) # for
Une seconde solution est de définir les fonctions adéquates, fonctions qui pourront avoir des nombres de paramètres divers selon l'élément qu'elles ont à traiter et d'utiliser l'unpacking
Code:

1 2 3 4 5 6 7 8 9 trt=( lambda n, p: "Nom: %s, prénom: %s" % (n, p), lambda a: "Age: %d" % a, lambda m: "Montant %.2f" % m, ) data=(("toto", "titi"), (18,), (12500.0,)) for (d, f) in zip(data, trt): print(f(*d))
Le val1 if expression else val2 lui est beaucoup plus simple à comprendre car on le retrouve sous diverses formes dans d'autres langages (ex C => expression ?val1 :val2)