Discussion :

[Aelurus_]

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 :

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

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

[fraborak]

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 ?

[Aelurus_]

du genre, dans une autre fonction corrective :

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
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 ^^

[fraborak]

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

[lg_53]

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 :

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

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

équivaut à

Code :

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

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 :

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

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

[Aelurus_]

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

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
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 ?

[Aelurus_]

Ok, en remplacent la boucle for par while

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
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.

[Aelurus_]

j'ai l'impression que

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
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.

[Aelurus_]

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

Merci

[wiztricks]

Salut,

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 :

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

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 :

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

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

[Aelurus_]

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.

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 ?.

[wiztricks]

Salut,

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

[Aelurus_]

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 :

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

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.

[lg_53]

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 :

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.

[Aelurus_]

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.

[wiztricks]

Salut,

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

[lg_53]

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.

[Aelurus_]

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 :

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

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

[wiztricks]

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

[Aelurus_]

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?