Comment initialiser un tableau à deux dimensions en Python?

Un modèle qui est revenu souvent dans Python a été

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

qui ont contribué à motiver l'introduction des interprétations de la liste, qui convertissent ce morceau de code à

bar = [SOME EXPRESSION for item in some_iterable]

qui est plus court et parfois plus clair. En général, vous obtenez l'habitude de reconnaissance de ces et souvent le remplacement des boucles avec des inclusions.

Votre code suit le modèle deux fois

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)                           /

Cette méthode est plus rapide de la liste imbriquée interprétations de la

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

Voici quelques python3 timings, pour les petites et les 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 des le même objet répété 10 fois. Vous ne pouvez pas utiliser, parce que la modification d'un élément ne permet de modifier le même élément dans chaque ligne!

x[:] est équivalent à list(X) mais est un peu plus efficace, car elle évite la recherche de nom. De toute façon, il crée une copie de chaque ligne, de sorte que maintenant, tous les éléments sont indépendants.

Tous les éléments sont les mêmes foo objet, si foo est mutable, vous ne pouvez pas utiliser ce dispositif., vous devez utiliser le

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

ou dans l'hypothèse d'une classe (ou une fonction) Foo qui renvoie foos

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

Pour initialiser un tableau à deux dimensions en Python:

a = [[0 for x in range(columns)] for y in range(rows)]

Habituellement, lorsque vous voulez les tableaux multidimensionnels vous ne voulez pas d'une liste de listes, mais plutôt un tableau numpy ou peut-être un dict.

Par exemple, avec numpy vous ferais quelque chose comme

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

Si c'est un peu densément peuplées tableau, vous pourriez être mieux à l'aide d'un dictionnaire à clé avec un n-uplet:

dict = {}
key = (a,b)
dict[key] = value
...

utilisation la plus simple de penser à créer cette.

wtod_list = []

et ajouter la taille:

wtod_list = [[0 for x in xrange(10))] for x in xrange(10)]

ou si nous voulons déclarer la taille d'abord. nous utilisons uniquement:

   wtod_list = [[0 for x in xrange(10))] for x in xrange(10)]

t = [ [0]*10 for i in [0]*10]

pour chaque élément, une nouvelle [0]*10 sera créé ..

Comme @Arnab et @Mike l'a souligné, un tableau n'est pas une liste. Peu de différences sont: 1) les tableaux sont de taille fixe lors de l'initialisation 2) les tableaux normalement soutien moins d'opérations que une liste.

Peut-être inutile dans la plupart des cas, mais ici, c'est un tableau 2d de mise en œuvre qui exploite le matériel de la matrice de mise en œuvre à l'aide de python ctypes(bibliothèques c)

import ctypes
class Array:
    def __init__(self,size,foo): #foo is the initial value
        self._size = size
        ArrayType = ctypes.py_object * size
        self._array = ArrayType()
        for i in range(size):
            self._array[i] = foo
    def __getitem__(self,index):
        return self._array[index]
    def __setitem__(self,index,value):
        self._array[index] = value
    def __len__(self):
        return self._size

class TwoDArray:
    def __init__(self,columns,rows,foo):
        self._2dArray = Array(rows,foo)
        for i in range(rows):
            self._2dArray[i] = Array(columns,foo)

    def numRows(self):
        return len(self._2dArray)
    def numCols(self):
        return len((self._2dArray)[0])
    def __getitem__(self,indexTuple):
        row = indexTuple[0]
        col = indexTuple[1]
        assert row >= 0 and row < self.numRows() \
               and col >=0 and col < self.numCols(),\
               "Array script out of range"
        return ((self._2dArray)[row])[col]

if(__name__ == "__main__"):
    twodArray = TwoDArray(4,5,5)#sample input
    print(twodArray[2,3])

C'est la meilleure que j'ai trouvé pour l'enseignement de nouveaux programmeurs, et sans l'aide de bibliothèques supplémentaires. J'aimerais quelque chose de meilleur.

def initialize_twodlist(value):
    list=[]
    for row in range(10):
        list.append([value]*10)
    return list

Souvent j'utilise cette approche pour l'initialisation d'un tableau en 2 dimensions

n=[[int(x) for x in input().split()] for i in range(int(input())]

from random import randint
l = []

for i in range(10):
    k=[]
    for j in range(10):
        a= randint(1,100)
        k.append(a)

    l.append(k)




print(l)
print(max(l[2]))

b = []
for i in range(10):
    a = l[i][5]
    b.append(a)

print(min(b))