Comment initialiser un tableau bidimensionnel en Python ?

Question

Je débute en python et j'essaie d'utiliser une liste à deux dimensions, que je remplis initialement avec la même variable à chaque endroit. J'ai trouvé ceci :

def initialize_twodlist(foo):
    twod_list = []
    new = []
    for i in range (0, 10):
        for j in range (0, 10):
            new.append(foo)
        twod_list.append(new)
        new = []

Il donne le résultat souhaité, mais ressemble à une solution de rechange. Existe-t-il un moyen plus simple, plus court ou plus élégant de procéder ?

Answer 1

Un modèle qui revenait souvent en Python était

bar = []
for item in some_iterable:
    bar.append(SOME EXPRESSION)

ce qui a contribué à motiver l'introduction des compréhensions de listes, qui convertissent ce bout de phrase en

bar = [SOME EXPRESSION for item in some_iterable]

qui est plus court et parfois plus clair. On prend généralement l'habitude de les reconnaître et de remplacer souvent les boucles par des compréhensions.

Votre code suit deux fois ce modèle

twod_list = []                                       \                      
for i in range (0, 10):                               \
    new = []                  \ can be replaced        } this too
    for j in range (0, 10):    } with a list          /
        new.append(foo)       / comprehension        /
    twod_list.append(new)                           /

Answer 2

Vous pouvez utiliser un compréhension de la liste :

x = [[foo for i in range(10)] for j in range(10)]
# x is now a 10x10 array of 'foo' (which can depend on i and j if you want)

Answer 3

Cette méthode est plus rapide que les compréhensions de listes imbriquées

[x[:] for x in [[foo] * 10] * 10]    # for immutable foo!

Voici quelques timings de python3, pour des petites et grandes listes

$python3 -m timeit '[x[:] for x in [[1] * 10] * 10]'
1000000 loops, best of 3: 1.55 usec per loop

$ python3 -m timeit '[[1 for i in range(10)] for j in range(10)]'
100000 loops, best of 3: 6.44 usec per loop

$ python3 -m timeit '[x[:] for x in [[1] * 1000] * 1000]'
100 loops, best of 3: 5.5 msec per loop

$ python3 -m timeit '[[1 for i in range(1000)] for j in range(1000)]'
10 loops, best of 3: 27 msec per loop

Explication :

[[foo]*10]*10 crée une liste du même objet répété 10 fois. Vous ne pouvez pas utiliser cette méthode, car la modification d'un élément modifiera ce même élément dans chaque rangée !

x[:] est équivalent à list(X) mais elle est un peu plus efficace puisqu'elle évite la recherche de noms. Dans tous les cas, elle crée une copie superficielle de chaque ligne, de sorte que tous les éléments sont maintenant indépendants.

Tous les éléments sont les mêmes foo cependant, donc si foo est mutable vous ne pouvez pas utiliser ce schéma, vous devez utiliser le schéma suivant

import copy
[[copy.deepcopy(foo) for x in range(10)] for y in range(10)]

ou supposer une classe (ou une fonction) Foo qui renvoie foo s

[[Foo() for x in range(10)] for y in range(10)]

Answer 4

[[foo for x in xrange(10)] for y in xrange(10)]

Answer 5

En général, lorsque vous voulez des tableaux multidimensionnels, vous ne voulez pas une liste de listes, mais plutôt un tableau numpy ou éventuellement un dict.

Par exemple, avec numpy, vous feriez quelque chose comme

import numpy
a = numpy.empty((10, 10))
a.fill(foo)