trouver valeur la plus prochje d'une autre

Bonjour, je vous expose mon probleme. Je dispose d’une liste de valeur de référence, et j’ai une autre qui est généré par des calcules (pour simplifier je fais juste un fois 2)

au lieu de faire une boucle statique for de 0 à 7, j’aimerais faire une boucle while, tant que les valeurs de ma listes input se rapproche de mes valeurs de ma liste de référence

ma question, es ce que python dispose d’une fonction pour comparer les valeurs de 2 listes ?

Humm, je n’en connais pas, mais je ne suis pas un expert en python.

Tout ce que je sais, c’est que ça dépend beaucoup de comment tu veux comparer ces listes. Tu peux simplement faire : abs( sum(a) - sum(b) ). Ça le mérite de se coder simplement, mais c’est pas super exacte.

Le mieux c’est d’avoir la liste des différences :

1
2
3

sum(map(lambda x,y: abs(x-y), a,b ) )
# Ou
sum([ abs( a[i] - b[i] ) for i in range(len(a)) ])

Il y a certainement d’autres méthode. Comme : min([ abs( a[i] - b[i] ) for i in range(len(a)) ]) ou encore : sum([ (a[i] - b[i])**2 for i in range(len(a)) ])

Edit: Après avoir lu la réponse de tleb, je suis parti du principe que c’était le calcule du delta qui te posait problème. Et c’est compréhensible, il existe plein de distance possible !

Salut,

Que-ce qui te pose problème dans la solution que tu proposes ? Il te suffit de vérifier que le delta est plus petit que celui de l’itération précédente (en stockant à chaque fois le delta calculé dans une variable et avec comme condition delta_actuel < delta_precedant).

@Cog3Cog3 : je ne suis pas sûr d’avoir compris ta question.

A priori, tu as une liste A, avec des nombres , disons 4 nombres. Une liste B, avec des nombres, disons 7 nombres. Et pour chaque nombre de A, tu cherches dans B le nombre qui est le plus proche, c’est ça ?

A = (40, 60, 110, 153) ; B = (45,48,70, 133, 275, 279,310)

Résultat = ((40,45),(60,70),(110,133),(153,133))

Je ne sais pas si c’est bien ça ton besoin… c’est tellement loin de la solution proposée par ache.

En fait, la question posée n’est pas assez précise. Il manque au moins deux informations :

Tes listes sont elles ordonnées (ça semble être le cas vu comment est posée la question, mais il vaut mieux s’en assurer) ?

Une valeur peut-elle être associée 2 fois ?

Bon du coup, Cog3cog3, explicite s’il te plait un peu plus précisément ton problème.

Je suis parti du principe :

1
2

a = [140,4,0,-30,6,7,-9,1]
b = list(map(lambda x: x*2,a)) # Pour simplifier, tu fais juste un fois 2

Après que cherches-tu à faire avec ces listes ?

excusez moi, j’ai cru que j’avais mis mon code…

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

def calc(list):
    return [i*2 for i in list]


list_reference=[1000,5000,2000,5000]
list_input=[400,3,0.2,5.6547]

for i in range(0,7):
    list_input=calc(list_input)

print(list_input)

je cherche une solution qui me donne le nombre d’itération a faire pour essayer d’avoir le plus de valeurs le plus proches de list_reference. Ces valeurs peuvent être supérieure ou inférieure a la valeur de référence. 400 doit se rapprocher de 1000 0.2 de 500 …etc.

Si en se rapprochant de 1000 je le dépasse, je passe par exemple de 800 à 1100 je considère que c’est mieux car la différence n’est que de 100 au lieu de 200

je ne pense pas que la solution de ache soit la meilleur, un sum ne "prouve rien", je me demande quel est la solution la plus pertinente pour faire ce genre de comparaison ?

l’idée c’est que la majorité des valeurs se rapproche de leurs référence et on arrête des que la majorité s’en éloignes. Si il y’a que 1/4 des valeurs qui s’éloigne de beaucoup c’est pas grave tant que les 3 autres quarts s’en rapproche.

Non effectivement, sommer des différences de valeurs qui ne sont pas du même ordre n’a pas de sens. Cela prendrait peut-être plus de sens en normalisant ou en utilisant des pourcentages (différence relative).

Tu ne peux pas t’arrêter quand la majorité s’en éloigne. Imagine que tu as les listes suivantes :

1
2

reference = [1, 1, 1, 1, 1]
comparison = [1, 0, 0, 1, 1]

Si tu t’arrêtes à la troisième valeur (index 2) en te disant que la majorité s’en éloigne, tu ne peux pas savoir que en continuant jusqu’à la fin la majorité sera proche. De toute façon "majorité" et "proche", ça ne veut pas dire grand chose.

Quel problème essaies-tu de résoudre avec cet algo ? J’ai l’impression que tu nous décris un problème XY.

En ligne 8-9 de ton code, tu multiplies par 2 7 fois de suite, donc tu multiplies par 128. C’est voulu ?

Tu dis qu’en face de 0.2, on doit obtenir 500. Mais 500 n’est pas dans list_reference… Et en face de 400, on ne veut pas voir 500, mais on veut voir 1000… ( peut-être à cause de cette fameuse multiplication par 2?)

Tout ça n’est pas clair du tout.

Je suis pas certain, mais si je résume, tu cherches le minimum de $i\mapsto \left\lVert X_{out}-Y_{in} 2^i \right\rVert$ ? Où la norme doit être celle qui quantifie les éléments sont le plus proche possible ? Selon le comportement de la norme tu peux utiliser un algorithme qui va te trouver le minimum (cf. scipy.optimize tu as une liste d’algo en dessous si tu veux le faire sans ça).

Pour le choix de la norme, c’est fortement dépendant de ton problème, de ce que représentent tes données et la notion de proche dans ce cas.