Discussion :

[Julienbot]

Bonjour à tous,

Je me permets de vous soumettre une petite question que je me pose, étant tout débutant en Python.

Je cherche en effet à créer un tableau de valeurs à 2 entrées puis en fonction des choix de l'utilisateur à en interpoler une donnée.
Concrètement, j'ai un tableau qui ressemble à ça :



Si l'utilisateur entre des valeurs pour paramètre 1 et paramètre 2 (par exemple 15 et 1700), je souhaiterais pouvoir afficher la valeur correspondante du tableau (en considérant que l'évolution des paramètre est linéaire entre deux lignes et deux colonnes).

Pourriez-vous me donner le petit coup de pouce pour savoir dans quelle direction partir. J'imagine qu'il faut travailler à partir de listes et de boules pour tester les valeurs, puis faire une interpolation linéaire (la seule partie que je pense savoir faire...).

Merci d'avance pour vos conseils qui me permettront certainement d'avancer.
Bonne journée,
Julien

[Julienbot]

Bonsoir,

J'ai finalement réussi à trouver une solution à mon problème. Mais je ne suis pas sûr que ce soit vraiment très propre... Mais en tous cas, ça marche !

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
>>> liste=[[12313,6565,5465],[23423,456,45656],[32424,4566,868678],[3424,46556,65644],[23424,23423,6544]]
 
>>> def interpol1(param1, param2i):
    if param1>=10 and param1<=20:
        resultat=liste[param2i][0]+(liste[param2i][1]-liste[param2i][0])*(param1-10)/(20-10)
    if param1>=20 and param1<=30:
        resultat=liste[param2i][1]+(liste[param2i][2]-liste[param2i][1])*(param1-20)/(30-20)
    return resultat
 
>>> def interpol(param1,param2):
    if param2>=0 and param2<=1000:
        resultat2=interpol1(param1,0)+(interpol1(param1,1)-interpol1(param1,0))*(param2-0)/(1000-0)
    if param2>=1000 and param2<=2000:
        resultat2=interpol1(param1,1)+(interpol1(param1,2)-interpol1(param1,1))*(param2-1000)/(2000-1000)
    if param2>=2000 and param2<=3000:
        resultat2=interpol1(param1,2)+(interpol1(param1,3)-interpol1(param1,2))*(param2-2000)/(3000-2000)
    if param2>=3000 and param2<=4000:
        resultat2=interpol1(param1,3)+(interpol1(param1,4)-interpol1(param1,3))*(param2-3000)/(4000-3000)
    return resultat2
 
>>> interpol(15,1500)
15217.25

Qu'en pensez-vous ? N'aurait-il pas moyen de mettre les paramètres dans une liste et d'écrire une boucle pour simplifier tout ca (voir permettre de faire la même chose sur un tableau plus grand sans tout devoir ré-écrire) ?

Merci d'avance pour vos réponses.

Julien

[fred1599]

Autre solution, créer un fichier csv (lisible sur excel), représentant les lignes et colonnes d'un tableau, à partir de là, avec le module csv, tu peux gérer tes données du tableau.

Qu'en penses-tu ? Je vois surtout un intérêt dans le fait d'éviter d'écrire en dur des données dans un code python...

[YCL-1]

Bonjour,

Vu que ton tableau est défini par les paramètres 1 et 2 ça serait plus facile d'utiliser des dictionnaires imbriqués plutôt que faire le lien avec les index, ça évite des conditions en cascades spécifiques au tableau.

Code :

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

1
2
3
4
5
6
7
tableau = {
	0:    {10: 12313, 20:  6565, 30:   5465},
	1000: {10: 23423, 20:   456, 30:  45656},
	2000: {10: 32424, 20:  4566, 30: 868678},
	3000: {10:  3424, 20: 46556, 30:  65644},
	4000: {10: 23424, 20: 23423, 30:   6544},
}

tableau[0][10] retourne 12313
tableau[1000][10] retourne 23423

On peut ainsi parcourir paramètre2 avec tableau.keys()

Voici ce que ç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
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
tableau = {
	0:    {10: 12313, 20:  6565, 30:   5465},
	1000: {10: 23423, 20:   456, 30:  45656},
	2000: {10: 32424, 20:  4566, 30: 868678},
	3000: {10:  3424, 20: 46556, 30:  65644},
	4000: {10: 23424, 20: 23423, 30:   6544},
}
 
def interpol1(param1, key_param2): # {
	max_value_p1 = min([max_value for max_value in tableau[key_param2].keys() if max_value >= param1])
	min_value_p1 = max([min_value for min_value in tableau[key_param2].keys() if min_value <= param1])
 
	return (
		tableau[key_param2][min_value_p1] +
		(tableau[key_param2][max_value_p1] - tableau[key_param2][min_value_p1]) *
		(param1 - min_value_p1) /
		# or 1 pour éviter la division par zéro dans le cas: max_value_p2 == min_value_p2
		((max_value_p1 - min_value_p1) or 1)
	)
# }
 
def interpol(param1, param2): # {
	max_value_p2 = min([max_value for max_value in tableau.keys() if max_value >= param2])
	min_value_p2 = max([min_value for min_value in tableau.keys() if min_value <= param2])
 
	return (
		interpol1(param1, min_value_p2) +
		(interpol1(param1, max_value_p2) -
		interpol1(param1, min_value_p2)) *
		(param2 - min_value_p2) /
		# or 1 pour éviter la division par zéro dans le cas: max_value_p2 == min_value_p2
		((max_value_p2 - min_value_p2) or 1)
	)
# }
 
# Interpolation
assert interpol(15, 1500) == 15217.25
assert interpol(10, 500) == 17868
# Valeur existantes
assert interpol(10, 1000) == tableau[1000][10]
assert interpol(20, 2000) == tableau[2000][20]
# Limites tableau
assert interpol(10, 0) == tableau[0][10]
assert interpol(10, 4000) == tableau[4000][10]
assert interpol(30, 0) == tableau[0][30]
assert interpol(30, 4000) == tableau[4000][30]

[Julien N]

Bonjour,

Si tu n'as rien contre réutiliser ce qui a déjà été fait, tu peux envisager de faire appel a l'une des fonctions d'interpolation du module scipy interp2d.

Il te faudrait restructurer un peu tes données. Il faut aussi envisager le cas de l'extrapolation. Même sans interp2d.

Ju

[Julienbot]

Bonjour à tous les trois.

Merci beaucoup pour vos réponses.
Pour l'instant je suis parti sur l'idée de fichiers CSV qui contiennent les tableaux de données.
J'essaierai au fur et à mesure de rendre tout ça plus propre.

Concernant l'extrapolation, ce n'est pas quelque chose que je prends en compte. Les tableaux utilisés sont des données certifiées et le domaine de calcul n'est donc utilisable qu'à l'intérieur du tableau.

Merci encore pour votre aide et à bientôt,
Julien