Discussion :

[jam7575]

Bonjour,
je désire connaître l'index d'une chaîne dans une liste.
Pas de problème pour une liste avec une seule dimension (liste[]).

Mon problème concerne une recherche dans une liste à deux dimensions (liste[][]) : je veux connaître l'indice d'une chaîne qui se trouve dans la première dimension.
Comment faire ?

Merci pour votre aide

[Sve@r]

Bonjour

Pas de problème pour une liste avec une seule dimension (liste[]).

Une liste 2D ce n'est qu'une liste de listes.
Boucle sur chaque "x" pris dans ta liste 2D et ce "x" sera lui-même une liste 1D avec laquelle tu n'as pas de problème.

[jam7575]

merci pour ce retour rapide que je ne suis pas sûr de bien saisir.
Si je comprends bien, il faut passer par une boucle, ce que je désire éviter.
A la limite c'est plus simple de décomposer ma liste 2D en 2 listes 1D, ainsi je peux limiter ma recherche par une seule instruction, sans boucle.
Cordialement

[Sve@r]

Si je comprends bien, il faut passer par une boucle, ce que je désire éviter.

Pourquoi donc ?

A la limite c'est plus simple de décomposer ma liste 2D en 2 listes 1D, ainsi je peux limiter ma recherche par une seule instruction, sans boucle.

En fait ce serait plutôt 2 instructions (recherche dans la liste 1 puis dans la liste 2).
Mais de façon générale, une liste 1D ne contient pas forcément que 2 items. De même donc une liste 2D ne contient pas forcément que 2 listes. Donc pour chercher une chaine dans une liste de n listes il faut fatalement passer par une boucle.

[wiztricks]

Si je comprends bien, il faut passer par une boucle, ce que je désire éviter.

Vous ne pouvez pas éviter de faire des boucles, juste les sous traiter à des méthodes/fonctions (qui feront le boulot plus efficacement si écrit en C). De plus, ce que vous racontez n'est pas clair... pourquoi ne pas l'illustrer avec une petite liste 2D et quelques lignes de codes?

- W

[jam7575]

Effectivement, je ne suis peut-être pas très clair, d'où ma mauvaise compréhension des réponses.

Voici ce que je voulais faire :

Code :

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

1
2
3
4
5
6
7
8
9
#! python3
# coding: utf-8
 
 
l1 = [['a', 1], ['b', 2], ['c', 3], ['d', 4]]
 
el = 'b'
 
ind = l1.index(el)

Je fournis 'b' pour obtenir in fine '2' (aspect non programmé ici).
Sans doute un dictionnaire répondrait mieux à mon besoin, mais je ne suis pas très familier des dictionnaires.
En scindant l1 en deux listes 1D mon problème est cependant aisément résolu. Mais le sujet m'intéresse.
Merci encore

[josmiley]

zip()

[jam7575]

Merci,
intéressant,
mais je ne vois pas en quoi ça résout mon problème.
Sans doute je deviens un peu lent de la comprenette...
Bonne soirée

[Sve@r]

mais je ne vois pas en quoi ça résout mon problème.

C'est vrai que moi aussi je ne vois pas trop quoi zipper. En revanche zipper "abcd" et "1234" donnera [['a', 1], ['b', 2], ['c', 3], ['d', 4]][x[0] for x in l1].index("b") => 1 (et pas de boucle(*) )

*: en fait si mais elle est cachée

[MPython Alaplancha]

Bonjour,
la demande est ambigüe:

Je fournis 'b' pour obtenir in fine '2'

ce qui laisse à penser que la valeur recherchée est la valeur [1] de la liste où se trouve 'b'
pourtant la variable que tu associes à cette valeur est nommée ind , ce qui évoque plutôt que ce serait un indice qui est recherché ...

Ceci étant dit l'opérateur 'in' est ton ami.

[fred1599]

Si je comprends bien, il faut passer par une boucle, ce que je désire éviter.

Sans doute un dictionnaire répondrait mieux à mon besoin, mais je ne suis pas très familier des dictionnaires.

Les deux sont contradictoires, d'abord, on cherche à faire ce qu'on veut, la manière de faire ne dépend pas de vous, mais des possibilités du langage !

Du coup choisissez ! Soit c'est le dictionnaire, soit c'est la boucle for, soit réinventez la roue !

Le moins simple pour un débutant, même quelqu'un de confirmé, c'est le dictionnaire

Code :

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

1
2
3
4
5
6
7
8
9
10
l1 = [['a', 1], ['b', 2], ['c', 3], ['d', 4]]
el = 'b'
 
# Convertir en dictionnaire
d1 = dict(l1)
 
# Trouver la valeur associée à `el` (si `el` est la clé)
value = d1.get(el, None)
 
print(value)  # 2

Le plus simple avec la boucle,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
l1 = [['a', 1], ['b', 2], ['c', 3], ['d', 4]]
el = 'b'
 
value = None
for letter, number in l1:
    if letter == el:
        value = number
        break
 
 
print(value) # 2

---

Mais de loin, j'ai l'impression d'un problème conceptuel, une liste 1D suffit

Code :

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

1
2
3
4
5
6
7
8
9
10
l1 = ['a', 'b', 'c', 'd']
el = 'b'
 
try:
    value = l1.index(el) + 1
except ValueError:
    value = None
 
 
print(value)

Je ne sais pas ce que vous cherchez à faire, mais d'un côté vous ne posez pas un cas concret, et votre demande technique sur la syntaxe n'est pas cohérente...
Dans tous les cas, soyez un minimum cohérent !

[jam7575]

Bonsoir,
désolé,
je m'explique sans doute mal.
Effectivement, la bonne solution est le dictionnaire, mais, pour une raison que je m'explique mal, j'ai toujours évité le dictionnaire.
Ceci dit la solution avec 2 listes est fort simple, moins élégante que le dictionnaire je le reconnais.

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
#! python3
# coding: utf-8
 
# avec une liste
 
l1 = [['a', 1], ['b', 2], ['c', 3], ['d', 4]]
 
el = 'b'
 
ind = l1.index(el) # el n'est pas trouvé
 
# avec deux listes
 
l1 = ['a', 'b', 'c', 'd']
l2 = [1, 2, 3, 4]
 
ind = l1.index(el)
valeur_recherchee = l2[ind]  # ou bien entendu valeur_recherchee = l2[l1.index(el)]

[fred1599]

Non votre solution avec deux listes n'est pas plus cohérente...

Il n'y a pas d'intérêt à faire cela, vous pouvez utiliser les indices de votre 1^ère liste pour déterminer la valeur correspondant à l'élément (voir ma 3^ème solution).

Avec la méthode index, si on ne trouve pas l'élément, on stoppe le programme avec un message d'erreur, il faut donc prévoir ce cas avec un bloc try-except.

Donc en plus d'être sans intérêt, la solution est incomplète !

[Sve@r]

Effectivement, la bonne solution est le dictionnaire

Il n'y a pas de "bonne" solution, comme il n'y a pas de "bon" outil. Il n'y a que des solutions (des outils), adaptés ou non adaptés. Mais surtout on ne choisit pas son outil par rapport aux recherches qu'on fera avec mais par rapport aux datas et à leurs traitements (bon certes les recherches sont aussi des traitements mais il faut savoir faire la part des choses).

Ceci dit la solution avec 2 listes est fort simple, moins élégante que le dictionnaire je le reconnais.

Et juste pour voir tu as testé ma solution ???

[jam7575]

merci encore,
je crains que le fait d'avoir mis des valeurs 1, 2, 3 , 4 n'ait induit certains en erreur.
En fait les vraies valeurs sont quelconques et n'ont aucun rapport avec leur position.
Le programme suivant (je n'ai modifié qu le cas des deux listes) est plus réaliste :

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
#! python3
# coding: utf-8
 
# avec une liste
 
l1 = [['a', 1], ['b', 2], ['c', 3], ['d', 4]]
 
el = 'b'
 
ind = l1.index(el) # el n'est pas trouvé
 
# avec deux listes
 
l1 = ['a', 'b', 'c', 'd']
l2 = [231, 1024, 832, 420]
 
ind = l1.index(el)
indice_recherche = l2[ind]  # ou bien entendu indice_recherche = l2[l1.index(el)]
valeur_recherchee_au_final = autre_liste[indice_recherche]

A cet endroit je n'ai pas besoin de try/except (que j'utilise volontiers par ailleurs) car je sais que la valeur recherchée existe. J'ai seulement besoin de savoir à quel endroit elle se trouve dans une autre (troisième) liste. Le fait d'appeler "valeur_recherchee" un indice intermédiaire a pu semer le trouble. Je voulais résumer la problématique au minimum. Erreur de ma part encore.

Mais je vais faire un effort psychologique et passer au dictionnaire un de ces jours...

Bonne nuit sans doute

[fred1599]

je crains que le fait d'avoir mis des valeurs 1, 2, 3 , 4 n'ait induit certains en erreur.
En fait les vraies valeurs sont quelconques et n'ont aucun rapport avec leur position.
Le programme suivant (je n'ai modifié qu le cas des deux listes) est plus réaliste :

réaliste = concret, là c'est mieux, apprendre à poser le problème est essentiel pour vous aider.

je n'ai pas besoin de try/except (que j'utilise volontiers par ailleurs) car je sais que la valeur recherchée existe

Dans ce cas votre solution est correcte, que recherchez vous exactement ?

La construction 2D n'est pas mieux ou moins bien, c'est un choix technique, mais à la vue de ce problème simple, le dictionnaire ou deux listes 1D semblent naturels ...

[wiztricks]

C'est vrai que moi aussi je ne vois pas trop quoi zipper.

Code :

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

1
2
3
4
>>> u, v = zip(*[['a', 1], ['b', 2], ['c', 3], ['d', 4]])
>>> v[u.index('b')]
2
>>>

- W

[MPython Alaplancha]

Mais je vais faire un effort psychologique et passer au dictionnaire un de ces jours...

Oui , c'est préférable. Tu as tout à y gagner.
Sinon pour te répondre:

Code :

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

1
2
3
4
5
6
7
>>> l1 = [['a', 1], ['b', 2], ['c', 3], ['d', 4]]
>>> for l in l1:
...     if 'b' in l:
...             print(l[1])
... 
2
>>>

Tu peux aussi écrire ce code sous la forme d'une fonction...

[josmiley]

zip()

Code :

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

1
2
3
4
>>> u, v = zip(*[['a', 1], ['b', 2], ['c', 3], ['d', 4]])
>>> v[u.index('b')]
2
>>>

- W

exactement ...

[MPython Alaplancha]

zip

Purement anecdotique, pour faire mumuse
Je sens que ça va beaucoup aider @jam7575