Discussion :

[Herevian]

Bonjour,
J'ai assez peu de connaissances en Python, mais je me lance dans un projet afin d'en apprendre un peu plus.
J'ai quelques idées pour résoudre mon problème, mais toutes complexes, et je n'arrive pas à me lancer, donc un peu d'aide serait la bienvenue.

Le principe est simple : j'ai créée deux classes, B et P, toutes deux ayant entre autres des attributs x et y. Je crée ensuite une classe W qui se construit à partir d'une instance de B et d'une liste d'instance P.
Le but serait d'écrire une méthode de W retournant la liste de P ordonnée selon la distance à l'instance B.

Ca ne me semble pas compliqué, mais je n'arrive pas à construire la fonction de façon à ce que cela retourne la liste des instances ordonnées et pas seulement les distances.

J'espère avoir été assez clair.

Merci d'avance pour votre aide !

[josmiley]

https://fr.wikipedia.org/wiki/Th%C3%...e_de_Pythagore

[wiztricks]

Salut,

Ca ne me semble pas compliqué, mais je n'arrive pas à construire la fonction de façon à ce que cela retourne la liste des instances ordonnées et pas seulement les distances.

Peut être construire une liste de tuple (p, distance(b,p)) puis la trier par ordre croissant ou en rangeant (p, distance(b, p)) à chaque itération.

- W

[Herevian]

https://fr.wikipedia.org/wiki/Th%C3%...e_de_Pythagore

Quelle intelligence et subtilité !

Salut,

Peut être construire une liste de tuple (p, distance(b,p)) puis la trier par ordre croissant ou en rangeant (p, distance(b, p)) à chaque itération.

- W

Ah oui en effet ça pourrait le faire ! Merci beaucoup.

[josmiley]

Quelle intelligence et subtilité !

désolé, j'avais mal compris la question.

[plxpy]

Bonsoir

Déjà, au vu de tes réponses lapidaires, tu bouffes de la distance euclidienne au petit-déjeuner. Pas la peine de t'en rappeler les principes.

Tu n'en dis pas trop quant à ton problème. Tu as décidé de faire X classes (je ne suis pas sur que ce soit la bonne solution mais je fais avec).

Si tes instances de classes B et P (au passage, ces noms ne sont pas terribles (politiquement correct. en vrai je pense "nuls à chier")) sont localisées, elles devraient hériter d'une classe "parent" qui saurait gérer la distance entre une instance et un "autre" objet localisé (attributs x et y).

J'ai pensé à ça (python 2, à adapter en version 3):

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
# coding: utf-8
 
import math
from random import randint
 
NB_POINTS = 10
XMAX, YMAX = 10, 10
 
class Point(object):
 
    def __init__(self, xy):
        self.x = xy[0]
        self.y = xy[1]
 
    def __str__(self):
        return "(%d, %d)" % (self.x, self.y)
 
    def dist(self, other):
        dx, dy = self.x - other.x, self.y - other.y
        return math.hypot(dx, dy)
 
 
class B(Point):
    pass
 
 
class P(Point):
    pass
 
 
def neighboors(B_instance, P_instances):
    distances = [(binst.dist(pinst), pinst) for pinst in P_instances]
    return [(t[1], t[0]) for t in sorted(distances)]
 
 
binst = B((0, 0))
 
# initialisation pour toujours avoir une distance nulle (verif)
pinsts = [P((binst.x, binst.y))]
 
# puis remplissage aléatoire
for _ in range(NB_POINTS):
    pinsts.append(P((randint(-XMAX, XMAX), randint(-YMAX, YMAX))))
 
 
result = neighboors(binst, pinsts)
for inst, distance in result:
    print inst, "distance :", distance

A l'usage, ça donne :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
pc41:Downloads pascal$ python neighboors.py
(0, 0) distance : 0.0
(2, 0) distance : 2.0
(1, 5) distance : 5.09901951359
(2, -5) distance : 5.38516480713
(1, -6) distance : 6.0827625303
(-3, -6) distance : 6.7082039325
(-1, 7) distance : 7.07106781187
(-9, -2) distance : 9.21954445729
(-8, -6) distance : 10.0
(10, -3) distance : 10.4403065089
(-10, -5) distance : 11.1803398875
pc41:Downloads pascal$

[josmiley]

peut-être ...

Code :

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

1
2
3
4
class W:
 
    def distances(self,p):
        return sorted(p,key=lambda point:(point.x-self.x)**2+(point.y-self.y)**2)

[Herevian]

Mon problème se basait surtout sur la communication entre B et P (dans mon programme, Building et Power, W étant World, j'avais décidé de faire abstraction des noms complets pour se focaliser sur le problème). Avec la technique du tuple, et en partie celle que vous proposez, ça m'aide beaucoup. L'idée étant qu'après, chaque B puisse récupérer une information sur P en itérant sur la liste ordonnée.

Tu as décidé de faire X classes (je ne suis pas sur que ce soit la bonne solution mais je fais avec).

Qu'elle seraient les solutions plus efficaces ? J'avoue que je pars sur ça sans vraiment savoir si c'est optimal, c'est un premier jet.

[plxpy]

Qu'elle seraient les solutions plus efficaces ? J'avoue que je pars sur ça sans vraiment savoir si c'est optimal, c'est un premier jet.

C'est très dur de te répondre sans connaître le contexte. En même temps, si c'est, comme tu dis, un premier jet, lance toi !

L'intérêt (l'un des intérêts) de python est de pouvoir tester/expérimenter ! Le code est suffisamment "ramassé" pour qu'on n'ait aucun regret à jeter quelques lignes à la poubelle si ça "ne le fait pas". Et essayer autre chose. Surtout, ne te bloque pas sur un truc qui ne fonctionne pas ou pas comme il faudrait.