Mise en abîme de listes - accès à un élément de la liste.

Version imprimable

Bonjour, je souhaite créer une listes constituée de sous-sous-...-sous listes dont le nombre est un paramètres de ma fonction (c'est le paramètre ordre).
Si j'ai une liste constituée de sous listes, je sais que je peux accéder à un élément en tapant L[i][j] (j ième élément de la ième liste).
Sauf que, étant donné le nombre de sous-sous-...-sous listes est un paramètre de ma fonction, je suis dans l'incapacité d'accéder à un élément en tapant L[i1][i2]...[i_k]

Je souhaiterais accéder à l'élément L[i1][i2]...[ik] de ma liste, connaissant les indices [i1,i2,...,ik].
J'ai réussi à créer le texte qui reproduirait l'instruction à taper, mais j'ignore si on peut transformer un texte en une instruction (par exemple, le texte "S=0" est lu comme une instruction par python. Si c'est possible, alors j'aurais résolu mon problème, bien que je n'ai à ma connaissance jamais vu quelque chose capable de faire ceci).
Autrement, auriez vous des pistes ou des solutions à mon problème ?

Je joins le code permettant de générer ma liste de listes de ... de listes.

Je vous remercie par avance pour vos réponses.
Code:

1 2 3 4 5 6 def Comptage(ordre,long,d): """d est un texte, ordre est le nombre de liste de liste de ... de liste que j'ai. Si ordre=5, j'ai des sous-sous-sous-sous-sous listes et donc un élément est L[i][j][k][l][m] [élément]""" L=[0 for i in range(long)] for i in range(ordre): L=[L for i in range(long)]
#Ce que je désire faire : L[i1][i2]...[i_ordre][indice]+=1 ajouterait 1 à l'élément i_ordre-ième de la (i_ordre)-1-ième de la ... de la i1-ième liste de ma liste L.

Salut,

Ton code ne semble pas correspondre à ce que tu veux faire.
Avec les arguments order = 3, long = 2:

Code:

1
2
3
4
5
6
7
8
9
10
11
[
 [
  [[0, 0], [0, 0]], 
  [[0, 0], [0, 0]]  # L[0][1][1][0]
 ],
 [
  [[0, 0], [0, 0]], 
  [[0, 0], [0, 0]]
 ]
]

Autre problème, tu ne fais que multiplier une seule même référence de la première liste.
Ci-dessus l'élément en caractère gras correspond à L[0][1][1][0]
vérifions avec ton code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
def Comptage(ordre,long,d):
    L=[0 for i in range(long)]
    for i in range(ordre):
        L=[L for i in range(long)]
 
    for l in L:
        print(l)
 
    L[0][1][1][0] = "*"
    for l in L:
        print(l)
 
Comptage(3, 2, "t")

résultat:

Code:

1
2
3
4
5
6
 
[[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
[[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
 
[[['*', 0], ['*', 0]], [['*', 0], ['*', 0]]]
[[['*', 0], ['*', 0]], [['*', 0], ['*', 0]]]

On peut aisément corriger ce dernier problème:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
def build_lists(order, long, root):
    item = [0 for i in range(long)]
    for o in range(order):
        root.append([item[:] for i in range(long)])
 
lists = []
build_lists(3, 2, lists)
for i in lists:
    print(i)
print()
lists[1][1][0] = "*"
for i in lists:
    print(i)

qui donne ceci

Code:

1
2
3
4
5
6
7
8
 
[[0, 0], [0, 0]]
[[0, 0], [0, 0]]
[[0, 0], [0, 0]]
 
[[0, 0], [0, 0]]
[[0, 0], ['*', 0]]
[[0, 0], [0, 0]]

mais peut-être que cela ne correspond pas encore à ton idée de sous-listes.

19/12/2020, 13h01
wiztricks

Salut,

Citation:

Envoyé par Pakotille

Autrement, auriez vous des pistes ou des solutions à mon problème ?

Déjà il faudrait savoir si vous voulez construire un tableau à N dimensions, ou si vous avez des listes contenant un nombre indéfini de sous listes de longueur variable.

- W
19/12/2020, 17h18
Sve@r
Bonjour

Citation:

Envoyé par Pakotille

mais j'ignore si on peut transformer un texte en une instruction (par exemple, le texte "S=0" est lu comme une instruction par python.

C'est possible avec eval().
Code:

1 2 3 4 5 6 7 8 9 >>> def f(s): print("s=", s) ... >>>f(s=5) s= 5 >>> >>>x="s=10" >>>eval("f(%s)" % x) s= 10 >>>
Pour le reste me semble que ton problème de création de listes nD ne peut se résoudre que par une fonction récursive. Quant à accéder à l'élément [x][y]...[z] sans préciser explicitement [x][y]...[z]...:?
19/12/2020, 18h07
wiztricks

Salut,

Citation:

Envoyé par Sve@r

C'est possible avec eval().

En partant d'un tuple i₁,i₂,...,i_k, pour faire l'équivalent de L[ i₁][i₂][...][i_k], on peut toujours faire une boucle et appeler __getitem__.
C'est possible sans eval.

- W
19/12/2020, 22h09
Sve@r

Citation:

Envoyé par wiztricks

En partant d'un tuple i₁,i₂,...,i_k, pour faire l'équivalent de L[ i₁][i₂][...][i_k], on peut toujours faire une boucle et appeler __getitem__.
C'est possible sans eval.

J'ai cité "eval" comme réponse à sa question <<< comment transformer un texte (ex "S=0") en instruction Python >>>.
Mais je n'avais pas pensé à boucler sur __getitem__ pour gérer le [x][y]...[z] ;)
20/12/2020, 22h11
lg_53
Si à chaque fois que vous descendez d'un niveau de sous liste, vous avez le meme nombre d'éléments (ce qui a l'air d'etre le cas), alors votre structure s'apparente à un tableau à multiple dimension. Et donc pour ca vous pourriez utilisez numpy, qui lui accepte qu'on lui donne des tuple.
Code:

1 2 3 4 import numpy as np x=np.zeros((3,2)) x[(1,1)]+=1
Et bien sur ca marche pas que pour un tableau 2D 3x2. Vous pouvez faire des tableaux à autant de dimension que vous voulez.

Code:

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
# créer les listes imbriquées (pareil que ta fonction, avec de la frime en plus)
from functools import reduce
create_nested_list = lambda long, order : reduce(lambda x,_ : [x]*len(x), range(order), [0]*long)
 
# Comme les listes imbriquées sont créées "en remontant", je pense qu'il n'est pas possible de se soustraire au mécanisme de références
# donc, supprimons les, après coup, "en descendant" 
def unref_list(lst):
    if isinstance(lst, list):
        lst = lst.copy() # <= suppression de la référence
        for i in range(len(lst)): # <= on passe aux listes "inférieures"
            lst[i] = unref_list(lst[i]) # <= on appelle la même fonction
    return lst # <= renvoi de la liste "déréférencée"
 
# Pour récupérer un élément, un boucle sur un tuple contenant les index  : 
def get_elt(L, indexes):
    for i in indexes:
        L = L[i] # <= récursif
    return L
 
#####################
##### Example #######
#####################
 
L = create_nested_list(long=2, order=4)
L = unref_list(L)
 
print('\n========== 1 =============')
print(L)
print('\n')
L[1][0][1][0][0] = 1
print(L)
 
print('\n========== 2 =============')
print(get_elt(L,(1,0,1,0,0)))
print(get_elt(L,(1,0,1,0)))
 
print('\n========== 3 =============')
elt = get_elt(L, (1,0,1,0))
for i in range(5):
    elt += [i]
print(L)

Peut-être qu'un peu de manipulation de texte peut convenir?

Code:

1
2
3
4
5
6
7
8
9
10
>>> txt = "S=1,2,3,4"
>>> k,v = txt.split('=')
>>> k
'S'
>>> v
'1,2,3,4'
>>> vals = v.split(',')
>>> vals
['1', '2', '3', '4']
>>>