Liste des objets les plus proches

Version imprimable

17/05/2016, 22h34
Herevian

Liste des objets les plus proches

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 !
18/05/2016, 11h31
josmiley

https://fr.wikipedia.org/wiki/Th%C3%...e_de_Pythagore
18/05/2016, 12h44
wiztricks

Salut,

Citation:

Envoyé par Herevian

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
18/05/2016, 22h44
Herevian

Citation:

Envoyé par josmiley

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

Quelle intelligence et subtilité !

Citation:

Envoyé par wiztricks

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.
18/05/2016, 23h03
josmiley

Citation:

Envoyé par Herevian

Quelle intelligence et subtilité !

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

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:

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:

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$

peut-être ...

Code:

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)

19/05/2016, 21h33
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.

Citation:

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.
19/05/2016, 21h59
plxpy

Citation:

Envoyé par Herevian

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.