Discussion :

[manaliac]

Bonjour,

A partir de deux listes j'essaie de créer une nouvelle liste contenant les deux premières listes avec quelques changements effectués.

Du genre :

liste1 =[a1,a2]
liste2 =[b1,b2]

et mon programme est du type : (simplifié)

Code :

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

1
2
3
4
5
6
7
8
for a in liste1:
    for b in liste2:
         if a[0] == b[0]:
 
            (val1,val2) = MatchData ( a,b) # ceci est une fonction qui renvoie deux vecteurs val1 et val2 qui contiennent soit la valeur 1 ou -1 ( logique)
             block = Construct_blk (val2,val1, a,b) # block est ma nouvelle liste
         else:
             continue

le problème est que la fonction Construct_blk remplace dans chaque boucle for un élément de la liste2 par un nouvel élément block.

Ce qui fait que liste2 se retouve avec des éléments block et que la boucle for se fait désormais sur la liste block !!!

Je n'arrive pas à corriger le problème !!
Je voudrais créer une liste à partir des deux premières sans qu'elles soient modifiées!!
Si vous savez comment éviter ce problème faites moi savoir!
M.

[N.tox]

Publier ta fonction construct_blk serait sûrement d'une grande aide pour pouvoir voir ce ne va pas à l'intérieur

plusieurs questions :

• quel est le type de a[0] ? un entier, un float, une liste, un tuple
• tu dis que val1 et val2 sont des vecteur ayant pour valeur 1 ou -1.. ça veux dire que ce sont des vecteur à une composante ? (ex: [1] ou [-1])
• concrètement, à quoi doit ressembler la troisième liste ?

Je voudrais créer une liste à partir des deux premières sans qu'elles soient modifiées!!

il te seras utile de retenir cette facon de copier une liste "a" : b=a[:]
pourquoi la copier ? pour une raison que le code expliquera mieux que moi ou de long discours :

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
>>> a=[1,2]
>>> b=a
>>> b.append(3)
>>> b
[1, 2, 3]
>>> a
[1, 2, 3]
>>> #b et a sont un seul et même objet
>>> #par contre
>>> a
[1, 2, 3]
>>> b=a[:]
>>> b.append(4)
>>> b
[1, 2, 3, 4]
>>> a
[1, 2, 3]

[eyquem]

Salut,



Quand une chose ne convient pas , il ne faut pas la faire:

modifier la liste dans laquelle on itère pose problème
=> il ne faut pas modifier la liste dans laquelle on itère.

Qui l’eût cru !?



Mais comme tu veux quand même bien modifier une liste, renversons les choses:

modifier la liste dans laquelle on itère pose problème
=> il ne faut pas itérer dans la liste qu’on modifie.



Donc il faut créer un double de la liste initiale pour itérer dedans.



Il se peut que cette proposition soit insuffisante, mais je pense comme N.tox: ton problème est exposé de façon trop imprécise pour pouvoir en dire plus.







2 remarques:



- il est illogique d’écrire:

dans chaque boucle for

Le mot “chaque“ donne à boucle la signification de “tour“, “pas d’itération“

la boucle for se fait désormais sur la liste

si la boucle se fait sur la liste, c’est qu’elle comporte plusieurs tours, un tour pour chaque élément C'est une itération

Dans deux phrases, le mot boucle signifie deux choses différentes.





- il n’y a pas de structure de données qui s’appellent vecteurs en Python. Pitié !, arrêtons d’employer ce terme qui ne veut rien dire.

[manaliac]

Bonjour,

Voici ma fonction Construct_blk simplifiée :

exemple de a : a =[1,12,1,15,2,6] ce sont des listes d'entiers
exemple de b : b=[1,20,1,10,1,15]
exemple de val1: val1 =[1,-1,1,1,-1,-1]

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
def Construct_blk(val2,val1,,a,b): # il y a plus d'instructions que cela mais elles sont basiquement pareilles
 
     if (val2[0]==-1 and val2(1] == -1):
        if val1[0]==1:
           b[1][0]= a[1][0]
 
        else:
           b[1][0]= a[1][3]
 
        if val1[1]== -1:
           b[1][1]= a[1][4]
        else:    
           b[1][1]= a[1][1]
     blk = a
     blk1 = blk.extend(b)
     block.append(blk1)    
     else:
         continue

la nouvelle liste doit ressembler à ce ci : block=[a, b_modifiée] si les conditions if sont vraies.

Je connais le principe de copier les listes soit par un : a =b[:] ou a = copy.copy(b), et je peux l'utiliser pour garder ma première liste intacte, mais cela ne résout pas mon problème!

Car une fois que ma nouvelle liste est créée, la partie b_modifiée est stockée dans la liste2 ( que cette liste2 soit copiée ou pas) et remplace la liste b ancienne, et donc cela ma crée des problèmes dans la boucle for:


M.

[eyquem]

Tes codes sont inutilisables , ils contiennent des fautes.


Le plus épineux c’est que si b=[1,20,1,10,1,15]
qu’est ce que b[1][0] ???!

[rambc]

Peut-être faudrait-il tout poser à plat ? Que cherches-tu à faire concrètement avec tes listes ? On pourra peut-être proposer une jolie solution...

[wiztricks]

Peut-être faudrait-il tout poser à plat ? Que cherches-tu à faire concrètement avec tes listes ? On pourra peut-être proposer une jolie solution...

S'il y avait eu un peu de conception descendante, nous ne parlerions plus de liste mais de classes. Pas facile d'apprendre à faire de la conception sur un domaine à découvrir avec des moyens d'expressions comme Python qui ne peuvent être utilisés pour "concevoir" que lorsqu'on est 'fluent'.
Je n'ai pas de solution.
- W

[manaliac]

Bonjour,

Le plus épineux c’est que si b=[1,20,1,10,1,15]
qu’est ce que b[1][0] ???!

Je suis désolée pour le mauvais exemple que j'ai donné ( dans mon idée de simplifier mon code et donc de simplifier mon erreur, je n'ai pas vraiment fait attention aux concordances d'indices)

Ceci est mon b[1] = [1,20,1,10,1,15]
mon b est du genre : b=[2,[1,20,1,10,1,15]]

Ce que mon code réalise est tout bête : je compare deux intervalles compris chacun dans des listes différentes, un des deux intervalles (liste2) doit être compris soit en partie soit en entier dans liste1 donc mes b dans liste2 sont en gros des listes d'intervalles: ou b[1]=[i_min,i_max,j_min,j_max,k_min,k_max]

Par exemple si mon b[1] =[1,20,5,10,1,15]
et que mon a[1] = [ 1,15,1,23,1,10] avec a =[2, [ 1,15,2,23,1,10],12,12]
alors ma nouvelle liste doit être : c = [a,b'] avec b' =[2,[1,15,5,10,1,10]] (donc ma liste b[1] est modifiée)

Au début, je voulais modifier le b[1] directement, mais cela changeait toute ma liste2 et donc cela faussait mes résultats.

J'ai finalement créé une liste x ayant la même structure ( nombre d'élément) qu'une liste b de la liste2 et ou je mets les changements que j'effectue.

J'ai toujours du mal à comprendre la logique des listes dans python qui est différente de fortran par exemple! (si b =a alors tout changement effectué sur b entraine un changement sur a)

Merci pour vos réponses !

M.

[wiztricks]

Salut
Tant que vous ne mettrez pas du "verbe" sur ces choses, çà restera dur à comprendre et à lire.

Un coup de pinceau sur:

Par exemple si mon b[1] = [1,20,5,10,1,15]->b
et que mon a[1] = [ 1,15,1,23,1,10]->a avec a =[2, [ 1,15,2,23,1,10],12,12]
alors ma nouvelle liste doit être : c = [a,b'] avec b' =[2,[1,15,5,10,1,10]->c]
(donc ma liste b[1] est modifiée)

Les a, b, c rouges sont des Listes de Segments
Un Segment est défini par des valeurs (min, max).

Si nous structurons un peu, ça donne:

Code :

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

1
2
a = List([Segment(1, 15), Segment(1, 23), Segment(1, 10)])
b = List([Segment(1, 20), Segment(5, 10), Segment(1, 15)])

Nous n'avons fait que mettre des noms sur les "objets" qui se dégagent d'une première lecture... Mais en leur donnant un "nom", ce ne sont plus de simple numéro d'index dans des listes de listes...
Avançons:

Ce que mon code réalise est tout bête : je compare deux intervalles compris chacun dans des listes différentes, un des deux intervalles (liste2) doit être compris soit en partie soit en entier dans liste1 donc mes b dans liste2 sont en gros des listes d'intervalles: ou b[1]=[i_min,i_max,j_min,j_max,k_min,k_max]

Ce qui en associant quelques verbes aux "choses" précédentes pourrait s'écrire:

Code :

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

1
2
if a.recouvre(b) :
   c = a.intersection(b)

Au bout du compte, nous n'avons fait que donner des noms et des verbes qui structurent un code proche de la description que vous en avez fait.
Ça ne dit pas trop comment cela va être réalisé - là seront les "détails", les optimisations et autre...
- W

[eyquem]

Le travail de clarification de wiztricks me permet de mieux être certain de ce qu’il faut comprendre.

Mais le nom “recouvre“ de méthode m’insatisfait un peu et je ne vois pas trop pourquoi intervient la méthode “intersection“.

--------------



En définitive, si je me fonde sur

avec a =[2, [ 1,15,2,23,1,10],12,12]
alors ma nouvelle liste doit être : c = [a,b'] avec b' =[2,[1,15,5,10,1,10]]

il s’agit de passer de

Code :

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

1
2
a = [2 , [1,15 , 2,23 , 1,10 ], 12,12 ]
b = [2 , [1,20,1,10,1,15] ]

à

Code :

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

c = [[2 , [1,15 , 2,23 , 1,10 ], 12,12 ]  , [2 , [1,15 , 5,10 , 1,10 ] ]

Est-ce bien ça ?
À partir de tes précédents posts, je ne comprends pas le pourquoi et le comment de cette déduction de c.









Je signale au passage qu’on peut transformer

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
def Construct_blk(val2,val1,,a,b): 
 
     if (val2[0]==-1 and val2(1] == -1):
        if val1[0]==1:
           b[1][0]= a[1][0]
 
        else:
           b[1][0]= a[1][3]
 
        if val1[1]== -1:
           b[1][1]= a[1][4]
        else:    
           b[1][1]= a[1][1]
     blk = a
     blk1 = blk.extend(b)
     block.append(blk1)    
     else:
         continue

en

Code :

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

1
2
3
4
5
6
7
8
9
10
11
def Slim_Construct_blk(val2,val1,,a,b):
 
    if val2[0:2]==[-1,-1]:
        b[1][0] = a[1] [    3*(val1[0]==-1)]
        b[1][1] = a[1] [1 + 3*(val1[1]==-1)]
 
     blk = a
     blk1 = blk.extend(b)
     block.append(blk1)    
     else:
         continue

et même en

Code :

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

1
2
3
4
5
6
7
8
9
10
def Slim_Slim_Construct_blk(val2,val1,,a,b):
 
    if val2[0:2]==[-1,-1]:
        b[1][0:2] = [ a[1] [3*(val1[0]==-1)] , a[1] [1 + 3*(val1[1]==-1)] ]
 
     blk = a
     blk1 = blk.extend(b)
     block.append(blk1)    
     else:
         continue

Ceci se fonde sur le fait qu’il n’y a que des 1 et -1 dans les objets val1 et val2 et que donc

Code :

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

1
2
3
4
5
        if val1[0]==1:
           b[1][0]= a[1][0]
 
        else:
           b[1][0]= a[1][3]

est équivalent à

Code :

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

1
2
3
4
5
        if val1[0]==-1:
           b[1][0]= a[1][3]
 
        else:
           b[1][0]= a[1][0]

Je n’ai pas cherché à corriger l’aberrante indentation.







Je crois avoir compris que ton problème est de “reserrer“ chaque intervalle d’une liste b en le comparant avec un intervalle dans une liste a.

Je pense ainsi que les 1 et -1 dans les séquences val1 et val2 rendent comptent si une limite d’intervalle a une valeur correcte par rapport à un intervalle de comparaison (par exemple borne_inf de l’intervalle comparé qui est supérieure à borne_inf de l’intervalle de comparaison).

Je me suis amusé à chercher comment faire avec Python, en conservant ta façon particulière de sérier des intervalles. Après quelques errements:

Code :

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

1
2
3
4
5
6
a = [ 2,12 , 13,26 ,  0,45 , 10,32 , 8,13 , 40,400 ]
b = [ 1,14 , 16,20 , -3,23 , 18,33 , 8,11 , 78,300 ]
 
T = [ [max(x,y),min(x,y)][i%2] for i,(x,y) in enumerate(zip(a,b)) ]
 
print a,'\n',b,'\n\n',T

Code :

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

1
2
3
4
[2, 12, 13, 26, 0, 45, 10, 32, 8, 13, 40, 400] 
[1, 14, 16, 20, -3, 23, 18, 33, 8, 11, 78, 300] 
 
[2, 12, 16, 20, 0, 23, 18, 32, 8, 11, 78, 300]

En sériant les intervalles de façon plus logique, comme l’a fait wiztricks, cela devient:

Code :

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

1
2
3
4
5
6
a = [ (2,12) , (13,26) ,  (0,45) , (10,32) , (8,13) , (40,400) ]
b = [ (1,14) , (16,20) , (-3,23) , (18,33) , (8,11) , (78,300) ]
 
T = [ (max(ix,iy),min(sx,sy)) for ((ix,sx),(iy,sy)) in zip(a,b) ]
 
print a,'\n',b,'\n\n',T

Code :

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

1
2
3
4
[(2, 12), (13, 26), (0, 45), (10, 32), (8, 13), (40, 400)] 
[(1, 14), (16, 20), (-3, 23), (18, 33), (8, 11), (78, 300)] 
 
[(2, 12), (16, 20), (0, 23), (18, 32), (8, 11), (78, 300)]

[wiztricks]

Salut,

Le travail de clarification de wiztricks me permet de mieux être certain de ce qu’il faut comprendre.

Heu, c'est gentil mais tu t'avances un peu car traduire ce que je peux avoir compris n'est pas nécessairement "la vérité vraie". Donc méfi!

Mais le nom “recouvre“ de méthode m’insatisfait un peu et je ne vois pas trop pourquoi intervient la méthode “intersection“.

D'après ce que j'ai compris on construit c à partir du moment ou tous les segments de a et b vérifient a(i) inclus dans b(i) ou b(i) inclus dans a(i).

Visuellement (faire un dessin) a recouvre b ou b recouvre a.

D'où le nom "recouvre" qui est discutable mais dès qu'on nomme quelque chose çà ouvre toujours "discussion" et c'est le but de la conception: est-ce que je traduis bien les choses du domaine?
On pourrait dire:

1. "recouvrable" plutôt que recouvre ou encore
2. "overlapping" ou encore
3. "p_235"

Normalement, je préfère (2) le "globish" ne faisant pas nécessairement référence à notre vécu, çà permet d'étiqueter les concepts de façon moins stérilisante pour la pensée avec que "p_235" en disant c'est un mot qui n'a que le sens qu'on lui a donné dans le domaine de cette conception

Si a et b vérifient cette propriété, c peut être construit à partir de l'intersection des segments de a et de b. Pour le coup, je ne vois pas l'intérêt de mettre un nom "particulier" à l'opération: çà à l'air de correspondre à ce qui doit être fait.
- W