Utiliser deux classes pour pouvoir créer une fonction

**abc_def** · 14/10/2021, 10h54

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 :

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

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

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

**wiztricks** · 14/10/2021, 11h12

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

**abc_def** · 14/10/2021, 11h16

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

**wiztricks** · 14/10/2021, 11h22

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

**abc_def** · 14/10/2021, 11h26

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

**Sve@r** · 14/10/2021, 11h54

Bonjour

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.

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.

**wiztricks** · 14/10/2021, 12h03

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

**Arioch** · 14/10/2021, 12h22

Pour le boulot, j'ai déjà souvent eu à faire une classe dont certains de ses attributs étaient des instances d'autres classes.

Code :

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

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 :

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

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.

**popo** · 15/10/2021, 12h06

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 :

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

**Sve@r** · 15/10/2021, 13h50

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

)

**wiztricks** · 15/10/2021, 19h27

ça fait beaucoup de lignes pour juste faire:

Code :

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

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

**popo** · 15/10/2021, 21h19

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.

**Sve@r** · 16/10/2021, 08h49

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

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

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

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

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)

Utiliser deux classes pour pouvoir créer une fonction

Python

Discussions similaires

Partager

Partager