Comment initialiser un tableau bidimensionnel en Python?

Je commence python et j'essaie d'utiliser une liste à deux dimensions, que je remplis initialement avec la même variable à chaque endroit. Je suis venu avec 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 contournement. Existe-t-il une manière plus simple / plus courte / plus élégante de procéder?

Un modèle qui est souvent apparu en Python était

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

qui a contribué à motiver l'introduction de listes de compréhension, qui convertissent cet extrait en

bar = [SOME EXPRESSION for item in some_iterable]

ce qui est plus court et parfois plus clair. Habituellement, vous avez l'habitude de les reconnaître et de remplacer souvent les boucles par des compréhensions.

Votre code suit ce 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)                           /

Vous pouvez utiliser une liste de compréhension :

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)

Ne l'utilisez pas [[v]*n]*n, c'est un piège!

>>> a = [[0]*3]*3
>>> a
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> a[0][0]=1
>>> a
[[1, 0, 0], [1, 0, 0], [1, 0, 0]]

mais

    t = [ [0]*3 for i in range(3)]

fonctionne très bien.

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 python3, pour les 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]*10crée une liste du même objet répétée 10 fois. Vous ne pouvez pas simplement l'utiliser, car la modification d'un élément modifiera ce même élément dans chaque ligne!

x[:]est équivalent list(X)mais est un peu plus efficace car il évite la recherche de nom. Quoi qu'il en soit, il crée une copie superficielle de chaque ligne, donc maintenant tous les éléments sont indépendants.

fooCependant, tous les éléments sont le même objet, donc s'il fooest modifiable , vous ne pouvez pas utiliser ce schéma., Vous devez utiliser

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

ou en supposant une classe (ou fonction) Fooqui renvoie foos

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

Pour initialiser un tableau bidimensionnel en Python:

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

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

Habituellement, 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)

Vous pouvez faire juste ceci:

[[element] * numcols] * numrows

Par exemple:

>>> [['a'] *3] * 2
[['a', 'a', 'a'], ['a', 'a', 'a']]

Mais cela a un effet secondaire indésirable:

>>> b = [['a']*3]*3
>>> b
[['a', 'a', 'a'], ['a', 'a', 'a'], ['a', 'a', 'a']]
>>> b[1][1]
'a'
>>> b[1][1] = 'b'
>>> b
[['a', 'b', 'a'], ['a', 'b', 'a'], ['a', 'b', 'a']]

twod_list = [[foo for _ in range(m)] for _ in range(n)]

pour n est le nombre de lignes, et m est le nombre de colonnes, et foo est la valeur.

S'il s'agit d'un tableau peu peuplé, il serait préférable d'utiliser un dictionnaire composé d'un tuple:

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

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

pour chaque élément un nouveau [0]*10sera créé.

Approche incorrecte: [[Aucun * m] * n]

>>> m, n = map(int, raw_input().split())
5 5
>>> x[0][0] = 34
>>> x
[[34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None]]
>>> id(x[0][0])
140416461589776
>>> id(x[3][0])
140416461589776

Avec cette approche, python ne permet pas de créer un espace d'adressage différent pour les colonnes externes et entraînera divers comportements inappropriés que vous attendez.

Approche correcte mais avec exception:

y = [[0 for i in range(m)] for j in range(n)]
>>> id(y[0][0]) == id(y[1][0])
False

C'est une bonne approche mais il y a une exception si vous définissez la valeur par défaut sur None

>>> r = [[None for i in range(5)] for j in range(5)]
>>> r
[[None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None]]
>>> id(r[0][0]) == id(r[2][0])
True

Définissez donc correctement votre valeur par défaut en utilisant cette approche.

Absolument correct:

Suivez la réponse du micro à double boucle .

Matrix={}
for i in range(0,3):
  for j in range(0,3):
    Matrix[i,j] = raw_input("Enter the matrix:")

Pour initialiser un tableau à 2 dimensions, utilisez: arr = [[]*m for i in range(n)]

en fait, arr = [[]*m]*ncréera un tableau 2D dans lequel tous les n tableaux pointeront vers le même tableau, donc tout changement de valeur dans n'importe quel élément sera reflété dans toutes les n listes

pour plus d'explications, visitez: https://www.geeksforgeeks.org/python-using-2d-arrays-lists-the-right-way/

utilisez la pensée la plus simple pour créer cela.

wtod_list = []

et ajoutez la taille:

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

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

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

Comme l'ont souligné @Arnab et @Mike, 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 prennent normalement en charge moins d'opérations qu'une liste.

Peut-être une surpuissance dans la plupart des cas, mais voici une implémentation de tableau 2D de base qui tire parti de l'implémentation de tableau matériel à l'aide de ctypes python (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])

La chose importante que j'ai comprise est: lors de l'initialisation d'un tableau (dans n'importe quelle dimension) Nous devons donner une valeur par défaut à toutes les positions du tableau. Ensuite, seule l'initialisation se termine. Après cela, nous pouvons changer ou recevoir de nouvelles valeurs à n'importe quelle position du tableau. Le code ci-dessous a parfaitement fonctionné pour moi

N=7
F=2

#INITIALIZATION of 7 x 2 array with deafult value as 0
ar=[[0]*F for x in range(N)]

#RECEIVING NEW VALUES TO THE INITIALIZED ARRAY
for i in range(N):
    for j in range(F):
        ar[i][j]=int(input())
print(ar)

Si vous utilisez numpy , vous pouvez facilement créer des tableaux 2D :

import numpy as np

row = 3
col = 5
num = 10
x = np.full((row, col), num)

X

array([[10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10]])

row=5
col=5
[[x]*col for x in [b for b in range(row)]]

Ce qui précède vous donnera un tableau 2D 5x5

[[0, 0, 0, 0, 0],
 [1, 1, 1, 1, 1],
 [2, 2, 2, 2, 2],
 [3, 3, 3, 3, 3],
 [4, 4, 4, 4, 4]]

Il utilise la compréhension de liste imbriquée. Répartition comme ci-dessous:

[[x]*col for x in [b for b in range(row)]]

[x] * col -> expression finale évaluée
pour x in -> x sera la valeur fournie par l'itérateur
[b pour b dans la plage (ligne)]] -> Itérateur.

[b pour b dans la plage (ligne)]] ceci évaluera à [0,1,2,3,4] puisque ligne = 5
alors maintenant il se simplifie pour

[[x]*col for x in [0,1,2,3,4]]

Cela évaluera à [[0] * 5 pour x dans [0,1,2,3,4]] -> avec x = 0 1ère itération
[[1] * 5 pour x dans [0,1,2, 3,4]] -> avec x = 1 2e itération
[[2] * 5 pour x dans [0,1,2,3,4]] -> avec x = 2 3e itération
[[3] * 5 pour x dans [0,1,2,3,4]] -> avec x = 3 4ème itération
[[4] * 5 pour x dans [0,1,2,3,4]] -> avec x = 4 5ème itération

C'est le meilleur que j'ai trouvé pour enseigner aux nouveaux programmeurs, et sans utiliser de bibliothèques supplémentaires. J'aimerais quelque chose de mieux cependant.

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

Voici un moyen plus simple:

import numpy as np
twoD = np.array([[]*m]*n)

Pour initialiser toutes les cellules avec une valeur 'x', utilisez:

twoD = np.array([[x]*m]*n

J'utilise souvent cette approche pour initialiser un tableau à 2 dimensions

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

Le modèle général pour ajouter des dimensions pourrait être tiré de cette série:

x = 0
mat1 = []
for i in range(3):
    mat1.append(x)
    x+=1
print(mat1)


x=0
mat2 = []
for i in range(3):
    tmp = []
    for j in range(4):
        tmp.append(x)
        x+=1
    mat2.append(tmp)

print(mat2)


x=0
mat3 = []
for i in range(3):
    tmp = []
    for j in range(4):
        tmp2 = []
        for k in range(5):
            tmp2.append(x)
            x+=1
        tmp.append(tmp2)
    mat3.append(tmp)

print(mat3)

Vous pouvez essayer ceci [[0] * 10] * 10. Cela renverra le tableau 2D de 10 lignes et 10 colonnes avec la valeur 0 pour chaque cellule.

lst = [[0] * m pour i dans la plage (n)]

initialiser toutes les matrices n = lignes et m = colonnes

Une autre façon consiste à utiliser un dictionnaire pour contenir un tableau à deux dimensions.

twoD = {}
twoD[0,0] = 0
print(twoD[0,0]) # ===> prints 0

Cela peut simplement contenir n'importe quelle valeur 1D, 2D et pour l'initialiser à 0ou toute autre valeur int, utilisez des collections .

import collections
twoD = collections.defaultdict(int)
print(twoD[0,0]) # ==> prints 0
twoD[1,1] = 1
print(twoD[1,1]) # ==> prints 1

Code:

num_rows, num_cols = 4, 2
initial_val = 0
matrix = [[initial_val] * num_cols for _ in range(num_rows)]
print(matrix) 
# [[0, 0], [0, 0], [0, 0], [0, 0]]

initial_val doit être immuable.

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