aide construction d'une boucle

Bonjour,



Je cherche à faire un saut dans l’incrémentation d'une boucle quand ma condition est remplie. pour l'instant j'ai ça

Code:

---

1 2 3 4 5 6 7 8 9 10

def make_paliers(values): sens = 0.025 nb_values = len(values) values_sep = []#Donne brute avec identification des étages for i in range(nb_values-1): if abs(values[i+1]-values[i])>sens and abs(values[i]-values[i+1])>sens: values_sep.append(-2.0) else: values_sep.append(values[i]) return values_sep

---

donc là à chaque fois que ma valeur remplit les conditions dans values_sep j'écris -2, c'est bien ce que je souhaite. Mais comment à partir de la faire en sorte que les x prochaines valeurs soient zappées. Pouvez-vous me donner une piste pour trouver là ou une solution.
Merci

tu peux faire une boucle while avec un incrément de i classique

while i < 10: par exemple

et quand tu arrives à ta valeur tu montes i d'un coup
par exemple si quand i = 3 c'est bon, tu mets i = 7 et tu as sauté les valeur 4 5 6

ça irait ?

du genre, dans une autre fonction corrective :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def clean_values(values): clean_values=[] n=len(values) print('nettoyage de',n,'valeurs.') for i in range(200): if values[i]==-2: clean_values.append(values[i]) a=0 while a<10: a=+1 i=i+a if a==10: return i else: clean_values.append(values[i]) return clean_values

---

mais dans ce cas la j'ai c'est comme si juste après le clean_values.append du if je met i=i+10, j'ai l'impression que cela ne touche pas au i du for, et la je me dit que je sais pas en fait ^^

je ne touche jamais au i d'un for

si j'ai besoin de le changer je fais un while avec un i+=1 dedans

non simplement en remplacant le for par un while. Car toute boucle for, est un while déguisé, dans lequel l'initialisation de la variable de boucle, et l'incrément de la variable de boucle se font tous seul automatiquement.

Je rappelle que :

Code:

---

1 2	for i in range(10) : print(i)

---

équivaut à

Code:

---

1 2 3 4

i = 0 while i<10 : print(i) i+=1

---

Donc avec ça en tête, on quand on traduit ce que fraborak dit, cela donne :

Code:

---

1 2 3 4 5 6 7

i=0 while i < 10: print(i) if i == 3 : i += 4 else : i+=1

---

bon avec un while un peu plus correct... (pas de coup de 12 please)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

values = [1,2,3,4,5,6,7,8,-2,1,2,3,4,5,6,7,8,23,10,11,12,13] def clean_values(values): clean_values=[] n=len(values) print('nettoyage de',n,'valeurs.') for i in range(n): if values[i]==-2: clean_values.append(values[i]) a=0 while a<=10: i+=1 a=a+1 else: clean_values.append(values[i]) return clean_values   a=clean_values(values) print(values) print(a)

---

Le i du for n'est pas touché, dois je rajouter un compteur en global ?

Ok, en remplacent la boucle for par while

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

values = [1,2,3,4,5,6,7,8,-2,1,2,3,4,5,6,7,8,23,10,11,12,13] def clean_values(values): clean_values=[] n=len(values) print('nettoyage de',n,'valeurs.') i=0 while i<=16: if values[i]==-2 or i<n: clean_values.append(values[i]) i+=4 else: clean_values.append(values[i]) i+=1 return clean_values   a=clean_values(values)

---

c'est bien ce que je souhaitais, faire. Il me faut maintenant gérer la taille de l'objet que je donne à cette fonction differement et ou corriger la fin de l'objet values.

j'ai l'impression que

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

values = [1,2,3,-2,1,2,3,4,5,6,-2,1,2,3,4,5,6,7,8,23,-2,1,2,3,4,5,6,-2,1,2,3,4,5,6] def clean_values(values): clean_values=[] n=len(values) print('nettoyage de',n,'valeurs.') i=0 vmoins=4 while i<=n-1: if values[i]==-2: clean_values.append(values[i]) i+=vmoins else: clean_values.append(values[i]) i+=1 return clean_values   a=clean_values(values)

---

semble fonctionner, mais je ne comprend pas tout ce qu'il ce passe dans ce code.
Le i<n fonctionne tres bien aussi.
Si je comprend bien, à chaque fois que "values" est == -2, j'écris la valeurs -2 dans clean_values, puis je remplace l'incrémentation de la boucle while de 1 à la valeur de vmoins.
si "values" est différent de -2, j'écris la valeur de "values" dans "clean_values" et je dit que l'incrémentation de la boucle while est de 1.
cela veut dire que à chaque -2 trouvé je perds vmoins*(nombre de -2 trouvé)-(nombre de -2 trouvé) de valeurs.

Une chose m'échappe, mais grand merci à tout les deux.

Si si ça répond tout à fait à la problématique rencontrée.

Merci

Salut,

Citation:

---

Envoyé par Aelurus_

Une chose m'échappe, mais grand merci à tout les deux.

---

Plutôt que de jouer avec le code, vous devriez déjà commencer par décrire à quoi ressemble la liste retournée par la fonction suivant ce quelle reçoit.

Après relisez votre code:

Code:

---

1 2 3 4 5 6 7

while i<=n-1: if values[i]==-2: clean_values.append(values[i]) i+=vmoins else: clean_values.append(values[i]) i+=1

---

dans tous les cas, on fait clean_values.append(values[i]), ce qui change c'est l'incrément de l'indice. Donc:

Code:

---

1 2 3 4 5 6

while i < n: clean_values.append(values[i]) if values[i] == -2: i += 3 else: i += 1

---

Très juste wizticks,
et je pense qu'il y a plus qu'une chose qui m'échappe aussi. Merci d'avoir pointé cette erreur de logique, je n'arrive pas prendre du recul sur ce que je fais. Je focalisais plus sur l'association que sur l'incrémentation.

Citation:

---

Envoyé par wiztricks

Plutôt que de jouer avec le code, vous devriez déjà commencer par décrire à quoi ressemble la liste retournée par la fonction suivant ce quelle reçoit.

---

Je comprends bien la partie jouer avec le code, qui me permet de vérifier la fonctionnalité avant la compréhension du code. Oui s'est un peu à l'envers.
Pour moi la description est :
La liste retournée par la fonction est la liste de valeurs numériques (ici des int) reçues à laquelle on écrit quand une valeur de cette liste est == à -2, la valeurs -2 et qu'on ignore les x valeurs suivantes, avant de reprendre l'association.

Si je comprends le sens de votre question, y aurait'il encore des erreurs de logique ?.

Salut,

Citation:

---

Envoyé par Aelurus_

Si je comprends le sens de votre question, y aurait'il encore des erreurs de logique ?.

---

J'ai des difficultés à comprendre quel devrait être le résultat lorsque la position de 2 -2 sont proches.
Par exemple: [ 1, 2, -2, 1, 2, -2, 1, 2, 3, 4]
Est ce qu'on sort: [ 1, 2, -2, 1, 2, 3, 4] ou juste [ 1, 2, -2, 1, 2, -2 ]

Je ne sais pas à quoi sert votre code et çà n'a sans doute aucune importance...
Mais comme vous avez des difficultés à programmer pas sûr que vous ayez bien traduit le besoin. D'où l'intérêt des exemples avec des cas "limites" qui permettent de s'assurer qu'on a bien compris le besoin (avant de coder).

- W

oui, effectivement dans cet exemple nous pouvons penser que les valeurs 2 et -2 ont un sens, alors que non.

Les valeurs -2 sont des marqueurs de j'insère dans la liste générée en amont. Toutes les valeurs de la liste sont des floats regroupé par une série de paliers ascendant et descendant.
Lors de ma detection de ces paliers

Code:

---

1 2 3 4 5 6 7 8 9 10 11

#Recuperation des valeurs pour detection separation des paliers avec -2 def make_paliers(values): sens = 0.025 nb_values = len(values) values_sep = []#Donne brute avec identification des étages for i in range(nb_values-1): if abs(values[i+1]-values[i])>sens and abs(values[i]-values[i+1])>sens: values_sep.append(-2.0) else: values_sep.append(values[i]) return values_sep

---

je récupère des faux paliers car le changement de paliers et pas très propre. Doc je me retrouvais avec des floats,-2, float, float,-2,-2,-2 presque à chaque palier. D'où l'idée d'enlever x valeur après la première détection d'un palier. Je n'ai pas pensé ou trouvé une autre solution au niveau de ce traitement. Donc dans cette logique et correction je peux continuer à corriger le reste ^^ et à continuer de faire des fonctions de ce que j'ai écrit. En essayant d'être plus propre, correct et cohérent.

Wiztricks ne vous à pas demander comment vous construisez vos valeurs. Et nous l'expliquez ne fait pas partie du problème de cette discussion. Si je le cite :

Citation:

---

Envoyé par wiztricks

D'où l'intérêt des exemples avec des cas "limites" qui permettent de s'assurer qu'on a bien compris le besoin (avant de coder).

---

Ce qui est demandé ici, ce sont des exemples. Donc en gros vous dites pour values = ... la fonction doit retourner blabla, et pour telle autre série values, la fonction va retourner truc. Ca permet de présenter clairement le résultat attendu.

Citation:

---

Envoyé par wiztricks

Salut,



J'ai des difficultés à comprendre quel devrait être le résultat lorsque la position de 2 -2 sont proches.
Par exemple: [ 1, 2, -2, 1, 2, -2, 1, 2, 3, 4]
Est ce qu'on sort: [ 1, 2, -2, 1, 2, 3, 4] ou juste [ 1, 2, -2, 1, 2, -2 ]

- W

---

Je pensais répondre à cette question, car l'exemple donner laissais à penser qu'il y avait une relation entre le traitement et la série de valeurs 2 -2. Donc pour [ 1, 2, -2, 1, 2, -2, 1, 2, 3, 4] si je choisi vmoins=6 la sortie est [1,2,-2,4] Je trouve trés hasardeux de disocier le résultat et de sa logique.

Salut,

Citation:

---

Envoyé par Aelurus_

Lors de ma detection de ces paliers je récupère des faux paliers car le changement de paliers et pas très propre. Doc je me retrouvais avec des floats,-2, float, float,-2,-2,-2 presque à chaque palier. D'où l'idée d'enlever x valeur après la première détection d'un palier.

---

Peut être faudrait-il retravailler votre idée de départ plutôt que corriger les dégâts qu'elle cause?
Une suite qui monte/descend et qui parfois est a peu près constant me ferait plutôt pencher à calculer le signe de différence entre 2 points consécutifs (une sorte de dérivée). Partant de N points on se retrouve avec N-1 valeurs dans { -1, 0, +1 }.
A vous de voir.

- W

Citation:

---

Envoyé par Aelurus_

l'exemple donné laissais à penser qu'...

---

Explicit is better than implicit.

La manière dont vous pensez, et dont pense chaque programmeur est différente. Donc il ne faut pas laisser la part à des choses implicite non dites.

Très juste wiztricks,

pourtant j'utilise déjà d(x)/d(t) (dérivation numérique car mes données ne sont pas dérivables par une fonction), par exemple, [0,0,0,0,1,0,1,0,1,1,0,1,1,1,1,1,1,1,1,1,2,0,1,2,2,2,2,2,2,2], ici il n'y a que trois paliers o 1 et 2. OU encore [0,0,0,0,0,1,0,1,2,3,4,3,2,1,1,1,1] et là c'est encore que deux paliers 0 et 1 et pas neuf.

Les dérivées me permettent bien cette détection, mais le problème à corriger pour le coup vient des données expérimentales. Je n'ai pas trouvé pour l'instant une autre méthode de traitement donc à défaut de mieux je reproduit bêtement ce que je fais "à la main".

Je peux me tromper mais il y a deux points à traiter, la détection et la validation de la détection.Une autre option de validation serait non pas de d'ignorer les n+x autres valeurs, mais de détecter l'obtention de la stabilité du palier. Option qui serait très bien dans le principe, mais plus difficile dans un premier temps pour mon petit niveau dans la manipulation, constaté, que j'ai des boucles ^^.
Mais à y réfléchir avec while et une meilleurs définition de la détection de paliers je pense que c'est jouable.

Code:

---

1 2 3 4 5 6

while i < n: clean_values.append(values[i]) if values[i] == -2: i += 3 else: i += 1

---

Il est bien entendu que ces propos ne sont encadrés qu'avec ce que je vois et connais.

Oui lg_53, je comprends mieux ton retour.

Merci

Citation:

---

Envoyé par Aelurus_

ppar exemple, [0,0,0,0,1,0,1,0,1,1,0,1,1,1,1,1,1,1,1,1,2,0,1,2,2,2,2,2,2,2], ici il n'y a que trois paliers o 1 et 2. OU encore [0,0,0,0,0,1,0,1,2,3,4,3,2,1,1,1,1] et là c'est encore que deux paliers 0 et 1 et pas neuf.

---

Ce que vous désignez par "palier" semble être une répétition de nombres.
[0,0,0,0,1,0,1,0,1,1,0,1,1,1,1,1,1,1,1,1,2,0,1,2,2,2,2,2,2,2]
Et la question serait alors "que faire des transitions?"

- W

je pense peut être saisir la subtilité soulignée, mais pas sur.

[0.0481,0.0417,0.0361,0.03,0.0232,0.0182,0.0177,0.0155,0.0155,0.0154,0.0154,0.0154,0.0157,0.0154,0.0154,0.0167,0.0154,0.0154,0.0154,0.0154,0.2595,0.2575,0.2561,0.2562,0.2561,0.2554,0.2551,0.2558,0.2556,0.2556,0.2555,0.2554,0.2553,0.2555,0.2556,0.2557,0.2552,0.2555,0.2556]

mais la subtilité du changement de paliers et des valeurs qui polluent sont quand même un peu plus pénible dans cette exemple.

Ensuite la subtilité entre transition (Passage graduel d'un état à un autre) et changement (passer d'un état à un autre) et effective, mais nous parlons toujours d'un changement d'état, n'est-ce pas?

Ensuite dans exemple minimum il y a minimum, j'ai résumé un cas défavorable pas tout les cas possible. En fait je ne comprend pas ou vous voulez en venir. Peut être aussi que le terme "palier" n'est pas correct en language informatique?

Citation:

---

Envoyé par Aelurus_

je ne comprend pas ou vous voulez en venir.

---

Moi non plus :mouarf:
Je cherche juste à comprendre vaguement le type de problème que vous essayez de traiter, histoire de savoir quel domaine de savoir pourrait avoir des solutions qu'il pourrait faire sens de regarder.

Là c'est un peu comme si on avait un signal avec du bruit qu'on chercherait à lisser. Et vous avez des tas d'algos. à voir côté traitement du signal voire même traitement d'image qui pourraient être intéressants.

- W

Lool,
en fait c'est le bruit des paliers que je veux récupérer, pas les aléas des transitions. Une fois qu'ils sont identifiés je peux les isoler pour ensuite faire des traitements assez simple dessus. Peut-être que le visuel des étapes sera plus parlant. La chose paraît plus compliquée qu'il n'y paraît. Je vais essayer de regarder si je trouve bibliothèque autre que matplotlib, cvs et numpy pour me faciliter la tâche.

Edit: et la en voyant les valeurs du paliers 2, je me questionnes sur la pertinence des 20 premieres récupérées.

Merci de votre intérêt