Discussion :

[larchicha]

Bonjour à tous,

Je me présente, Jay, débutant en python.
Je rencontre quelques problèmes sur certains exercices...

On me demande de créer une fonction qui prend 2 listes d'entiers en argument, et qui vérifie que les éléments de la première liste sont dans la deuxième, dans le même ordre.
Tel que : list1 = [2,3,4] list2=[1,2,3,4,5] renvoie True
list1 = [2,3,4] list3=[1,2,4,3,5] renvoie False


Je lutte sur le même ordre... quoique je ne suis même pas sûr que le reste soit bon, enfin je vous laisse juger.

Mon code :

Code :

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

1
2
3
4
5
6
7
8
 
def test_list(list1, list2):
       for element in list1: # je parcours la liste 1
           for i in range(len(list1)): # j'indice la liste 1 pour respecter l'ordre
                 if list1[i] != list2[i]: #  problème  
                        return False    
            if element not in list2:    
       return True

le problème que je vois est que : en voulant respecter l'ordre, je fais en sorte que chaque élément de la liste 1 soit exactement dans la liste 2 à la même place, or ce qu'on me demande : pouvoir barrer des elements de la liste 2 pour retrouver la liste 1.

Je m'embrouille un peu beaucoup pour ce qui semble être la base de Python...

Je vous remercie d'avance pour vos réponses.

Jay.

PS : Merci pour le Tips ValAa

[valAa]

Bonjour à toi,

PS : Désolé l'indentation n'est pas respectée...

Il ne faut pas être désolé, il faut corriger ça : c'est que sans cette indentation, on ne peut même pas savoir ce qu'est sensé faire le bout de code que tu donnes, vu qu'on ne sait pas où s'arrêtent les différents blocs. Ça va être dur de t'aider.

Je te conseille de mettre ton bout de code en deux balises CODE, que tu obtiens en utilisant le bouton '#' dans la barre d'outil de rédaction de message.
Ainsi l'indentation sera respectée.

edit : et il faudrait compéter un peu ton énoncé :
que doit-il se passer :

list1 = [2,3,4]
et :
list2 = [5, 1, 2, 9, 3, 4]

à savoir qu'on retrouve les mêmes éléments, dans le même ordre, mais pas consécutifs ?

[larchicha]

list1 = [2,3,4]
et :
list2 = [5, 1, 2, 9, 3, 4]

à savoir qu'on retrouve les mêmes éléments, dans le même ordre, mais pas consécutifs ?

Exactement... de façon à ce que si je barre les éléments 5 , 1 , 9 de la 2eme liste, je retrouve la première liste.

[N.tox]

c'est peut-être pas ce qu'il y a de plus élégant ou propre, et je l'ai fait à l'arrache, mais ça fonctionne :

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
def func(lstI,lstII):
    lstII = lstII[:]
    lI,lII = len(lstI), len(lstII)
    if lI < lII:
        small, big = lstI, lstII
    elif lI>lII:
        small, big = lstII, lstI
    else:
        return lstI==lstII #retourne True ou False
    print "not same length"
 
    #elimination des éléments de big non présents dans small
    idx=0
    while 1:
        if big[idx] not in small:
            del big[idx]
        else :
            idx += 1
        if idx >= len(big): break
    print 'first cleaning', small, big
 
    #vérification de la présence de chaque élément de small dans big
    for x in small:
        if x not in big : return False
        elif small.count(x) > big.count(x): return False
    print 'each element of small are in big'
 
    #vérification de l'ordre
    idx_big = idx_small = 0
    ls                  = len(small)
    while 1:
        print 'compare', small[idx_small], big[idx_big]
        if big[idx_big]     == small[idx_small] :
            idx_big         += 1
            if idx_small+1   < ls : idx_small +=1
            elif big[:idx_big]==small : return True
        else :
            del big[idx_big]
        if small == big : return True
        elif idx_big >= len(big):
            print 'index error on big'
            return False

Test :

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
>>> func([2,3,4], [5, 1, 2, 9, 3,2,3, 4, 3, 4])
not same length
first cleaning [2, 3, 4] [2, 3, 2, 3, 4, 3, 4]
each element of small are in big
compare 2 2
compare 3 3
compare 4 2
compare 4 3
compare 4 4
True
>>> func([2,3,4], [5, 1, 2, 9, 4, 3])
not same length
first cleaning [2, 3, 4] [2, 4, 3]
each element of small are in big
compare 2 2
compare 3 4
compare 3 3
index error on big
False

[larchicha]

Joli coup...
Au premier coup d'oeil, je comprend ton code, mais bon la tu m'as donné la réponse...(ce dont je te remercie).

Maintenant, quand tu lis mon code, que me conseilles tu de faire pour améliorer mon code d'une part, et mon ' algorithmie ' d'autre part, parce que je sens bien que c'est une grosse lacune chez moi...:'(

[eyquem]

Bonjour, et bienvenue dans ce forum, Jay

vérifier que les éléments de la première liste sont dans la deuxième, dans le même ordre.

J’interpréte ainsi:
[26,3,9,13] est bien dans [2,4,89,26,908,3,14,9,75,13,10]

L’exemple que tu donnes ne me permet pas cependant pas d’être sûr que j’interprète correctement car il est restrictif par rapport à ce cas général.
En effet si li = [2,4,89,26,908,3,14,9,75,13,10]
alors li[2:6] == [89,26,908,3]
et on peut dire que la liste [89,26,908,3] est dans la liste li, et non plus ses éléments.
Si c’est le cas, l’algorithme pour vérifier cela est différent et plus simple que dans le cas général.




Il y avait un autre point ambigu. valAa en a obtenu l’éclaircissement.



Il y a encore une autre incertitude.
Si liste 1 = [76,84,93]
est-ce que ses éléments se trouvent dans liste2 dans le même ordre avec
li = [2,3,3,4,60,76,76,76,80,83,83,84,92,93]
ou
li = [2,3,3,1,4,60,76,78,76,80,76,83,83,84,92,93] ?





Concernant ton code:

Code :

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

1
2
3
           for i in range(len(list1)): # j'indice la liste 1 pour respecter l'ordre
                 if list1[i] != list2[i]: #  problème  
                        return False

se trouve dans une boucle for element in list1: mais ne comporte pas la référence element.

La présence de cette deuxième boucle en i dans la première boucle sur element consiste donc à refaire la même chose pour tous les éléments de liste1. L’intérêt en paraît faible.



Autre problème: tu limites la plage de variation de i à la longueur de liste1 alors que dans ton exemple l’élément 4 dans liste2 est à un indice au delà. Rien que sur ton exemple, on voit donc qu’il y a un problème.





Il faut commencer par avoir une idée claire de l’algorithme (stade papier crayon) avant de le mettre en code.

Il est de bon sens de commencer par for element in list1:

Mais ensuite, pour ne pas rester dans le vague de la formulation “dans le même ordre“ il faut la décomposer en une formulation plus concrète: “l’ordre des élements de liste1 dans liste1 est le même que l’ordre des éléments de liste1 dans liste2“. À partir de là, on peut se poser la bonne question: concrètement, qu’est ce que l’ordre d’éléments , comment le représente-t-on ?

[eyquem]

Impressionant, N.tox

Mais je pense qu’il y certainement des solutions plus simples. Je n’ai pas écrit les codes, mais j’en ai l’idée de deux.

En fait , il faudrait plus de précision encore sur les cas susceptibles d’être rencontrés: doublons dans une liste possible ? dans les deux ?

[larchicha]

Awesome...

Le problème est beaucoup plus clair déja mais sur l'énoncé, il n'y a pas le cas des doublons, qui est certes important donc à mon avis implicite...

Par contre, pour le cas particulier, de la liste DANS la liste, et non plus le cas général des éléments dans la liste, je suis assez d'accord avec toi car cela respecte l'énoncé en réduisant le problème mais, cela revient à faire plusieurs parties dans mon code pour les différents cas ? (en étant très perfectionniste)

Merci encore de vos réponses .

[N.tox]

Impressionant, N.tox

Mais je pense qu’il y certainement des solutions plus simples. Je n’ai pas écrit les codes, mais j’en ai l’idée de deux.

En fait , il faudrait plus de précision encore sur les cas susceptibles d’être rencontrés: doublons dans une liste possible ? dans les deux ?

Normalement, l'algorithme horrible que j'ai pondu couvre les cas des doublons dans chacune des listes ou dans une seule...

Ceci dit, je suis positivement curieux de voir un autre algorithme bien plus élégant (et performant, cause le mien... hum hum)

@larchicha : pour améliorer ton algorithmie, d'une manière générale, comme l'a très bien dit eyquem : pose noir sur blanc le but de façon clair, puis décompose le en étapes tout aussi clair (éventuellement corrige), et répète ce processus jusqu'à arriver pratiquement au code... en parallèle, y'a pas de secret : faut se planter, corriger, tester à nouveau, et encore corriger, tester, et ça même sur des petites choses, comme bien comprendre le mécanisme d'une boucle for, d'ailleurs à ton avis, pourquoi ais-je utiliser while plutôt que for ? (tu pourras demander la réponse si tu veux hein... j'te la donnerais alors) Trouve la réponse à cette question et t'auras bien compris une des particularités de for

[larchicha]

De but en blanc je dirais que tu utilises le while 1: <-> while True:

car pour le for tu as une limite qui est la taille de ta liste. Or quand tu mets while True: , je vois que la limite est celle que tu décides , soit : if ... == ... :break

Ou je suis completement à coté de la plaque :p

Ca me fait penser au JAVA, où on utilise le for lorsqu'on sait combien de ' tours ' on va devoir faire, et le while sinon...

[N.tox]

c'est tout à fait ça, mais du coup j'ai re-tester un truc simple, et... en fait j'avais pas bien capter tous les mécanismes de for

Code :

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

1
2
3
4
5
6
7
8
9
>>> l=[1,2,3]
>>> for x in l:
	try : del l[2]
	except : None
	print x
 
 
1
2

Du coup, à première vue y'a sûrement plusieurs fois où on pourrait avantageusement remplacer des boucles while dans mon algorythm

[eyquem]

while / for : je pense que ce que tu dis est ce que N.tox a voulu pointer

pour le cas particulier, de la liste DANS la liste, et non plus le cas général des éléments dans la liste, (...) cela revient il à faire plusieurs parties dans mon code pour les différents cas ?

Ce n’est pas ce que j’ai voulu dire. D’ailleurs je crois qu’il est incohérent d’envisager deux sortes de traitement dans le code, correspondant au cas général et au cas particulier, car comment donc se ferait le choix du traitement activé lors de l’exécution, si ce n’est par la connaissance préalable que les listes en argument correspondent à un cas plutôt que l’autre......
Or on ne peut pas vouloir faire trourner un programme pour obtenir un résultat dont on a d’abord besoin pour choisir le cas de traitement qui convient !


Enfin bref, comme disait Pépin.....
La raison de ma question est toute simple: je pensais à l’algorithme suivant qui n’est valable que pour le cas restreint:

Code :

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

1
2
3
4
5
li = [34,78,9,42,45,66,13,88,1,7]
mi = [9,42,45,66]
lg = len(mi)
for k in xrange(len(li)-lg+1):
    print 'li['+str(k)+':'+str(k+lg)+'] = ',li[k:k+lg],mi==li[k:k+lg]

li[0:4] = [34, 78, 9, 42] False
li[1:5] = [78, 9, 42, 45] False
li[2:6] = [9, 42, 45, 66] True
li[3:7] = [42, 45, 66, 13] False
li[4:8] = [45, 66, 13, 88] False
li[5:9] = [66, 13, 88, 1] False
li[6:10] = [13, 88, 1, 7] False

Au passage , je reconnais que mon appellation de liste DANS liste est impropre:
le = [ ’d’,’r’,[’poi’,’we’,’cv’],’q’]
[’poi’,’we’,’cv’] est dans le et ça ne correspond pas au cas que j’ai appelé DANS.



Bon, ne parlons plus que du cas général et quelconque sans doublons, qui est celui qui t’occupe.

Normalement, l'algorithme horrible que j'ai pondu couvre les cas des doublons dans chacune des listes ou dans une seule...

C’est bien. Mais c’est ce genre d’effort que j’ai voulu éviter si le cas ne se posait pas.

Ceci dit, je suis positivement curieux de voir un autre algorithme

Pour le cas général sans doublons de larchida, j’ai un code qui n’est pas vraiment un algorithme. Il tient en une ligne.

Code :

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

1
2
3
it = [2,4,89,107,22,26,908,77,1,542,14,3,13,9]
itif = [89,26,908,3]
print [or]==tttnnnnnfffffffiiiiiiiiiii

J’ai camoufllé la dernière ligne (après le print) ... devinette !

EDIT: correction de la liste it




Si tu connais JAVA, tu es un faux débutant. Tu vas te régaler avec Python, c’est beaucoup plus simple à écrire.

[N.tox]

Pour le cas général sans doublons de larchida, j’ai un code qui n’est pas vraiment un algorithme. Il tient en une ligne.

Code :

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

1
2
3
it = [2,4,89,26,908,3,14,9,75,13,10]
itif = [89,26,908,3]
print [or]==tttnnnnnfffffffiiiiiiiiiii

J’ai camoufllé la dernière ligne (après le print) ... devinette !

Bon, je pense pas que ce soit ça que tu ai camouflé, mais je tente :p

Code :

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

1
2
3
4
>>> it = [2,4,89,26,908,3,14,9,75,13,10]
>>> itif = [89,26,908,3]
>>> print True in (itif==it[x:x+4] for x in xrange(len(it)-1))
True

[eyquem]

Je suis un gros nul.
Je me suis trompé en écrivant les listes d’exemple.

Ma solution est valable pour le cas général, évidemment,
c’est a dire même pour

Code :

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

1
2
it = [2,4,89,107,22,26,908,77,1,542,14,3,13,9]
itif = [89,26,908,3]

Cette erreur t’a induit en erreur, N.tox, sinon il y a de ça dans le début de ton code

[N.tox]

hmmm...ceci ?

Code :

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

1
2
3
4
>>> itif = [89,26,908,3]
>>> it = [2,4,89,107,22,26,908,77,1,542,14,3,13,9]
>>> print itif==filter(lambda x, lst=itif: x in lst, it)
True

[eyquem]

C’est ça, mais il n’y a pas de ’l’, il n’y a pas de ’a’ dans ma ligne camouflée.
Il faut réutiliser exactement les lettres disponibles dans cette ligne pour obtenir ma solution.

Pourquoi t’embêtes tu avec filter() ?
Et en plus, en compliquant, car
print itif==filter(lambda x: x in itif, it)
marche aussi.

NB ai choisi un nom dans la ligne qui trouble les choses et rend la ligne plus drôle

[N.tox]

alors ceci :

Code :

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

1
2
3
4
>>> itif = [89,26,908,3]
>>> it = [2,4,89,107,22,26,908,77,1,542,14,3,13,9]
>>> print itif==[defin for defin in it if defin in itif]
True

Sinon, ben... je donne ma langue au chat

EDIT : je verrais plus ça comme ça remarque

Code :

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

print itif==[_def for _def in it if _def in itif]

[eyquem]

Eh bien oui, c’est ça, bravo, mais pourquoi introduis tu deux lettre ’e’ et ’d’ ?

Ce qui correspond à ma ligne camouflée, c’est

Code :

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

itif==[ inf for inf in it if inf in itif ]

On peut faire plus court si on veut:

Code :

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

1
2
3
i = [2,4,89,107,22,26,908,77,1,542,14,3,13,9]
oo = [89,26,908,3,5]
print oo == [o for o in i if o in oo]

À part ça, Jay ne connaît sans doute encore pas les list comprehension et pour le mettre sur la voie d’une solution parmi d’autres , je réponds a la question que j’ai évoquée: concrètement, qu’est ce que l’ordre d’éléments , comment le représente-t-on ?

Je répondrais qu’une liste d’indices d’objets dans une liste représente leur ordre dans cette liste.

Mais que pour comparer deux listes d’indices, il ne faut pas procéder de façon brutale par égalité pure.

[N.tox]

Eh bien oui, c’est ça, bravo, mais pourquoi introduis tu deux lettre ’e’ et ’d’ ?

Ce qui correspond à ma ligne camouflée, c’est

Code :

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

itif==[ inf for inf in it if inf in itif ]

c'est un humour qui me fait penser qu'il faut que je m'aère un peu la tête

[larchicha]

J'ai compris ce qui allait pas, donc un grand merci à vous.

PS: Problème Résolu.