Comment définir un tableau à deux dimensions en Python
Je veux définir un tableau à deux dimensions sans une longueur initialisée comme ceci:
Matrix = [][]
mais ça ne marche pas ...
J'ai essayé le code ci-dessous, mais c'est faux aussi:
Matrix = [5][5]
Erreur:
Traceback ...
IndexError: list index out of range
Quelle est mon erreur?
Vous essayez techniquement d'indexer un tableau non initialisé. Vous devez d'abord initialiser la liste externe avec des listes avant d'ajouter des éléments; Python appelle cela "Liste compréhension".
# Creates a list containing 5 lists, each of 8 items, all set to 0
w, h = 8, 5;
Matrix = [[0 for x in range(w)] for y in range(h)]
Vous pouvez maintenant ajouter des éléments à la liste:
Matrix[0][0] = 1
Matrix[6][0] = 3 # error! range...
Matrix[0][6] = 3 # valid
print Matrix[0][0] # prints 1
x, y = 0, 6
print Matrix[x][y] # prints 3; be careful with indexing!
Bien que vous puissiez les nommer comme vous le souhaitez, je le regarde de cette façon pour éviter toute confusion pouvant survenir avec l'indexation, si vous utilisez "x" pour les listes intérieure et extérieure et que vous souhaitez une matrice non carrée.
Si vous voulez vraiment une matrice, mieux vaut utiliser numpy. Les opérations de matrice dans numpy utilisent le plus souvent un type de tableau à deux dimensions. Il existe plusieurs façons de créer un nouveau tableau. L’une des plus utiles est la fonction zeros, qui prend un paramètre de forme et renvoie un tableau de la forme donnée, avec les valeurs initialisées à zéro:
>>> import numpy
>>> numpy.zeros((5, 5))
array([[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
numpy fournit également un type matrix. Il est moins couramment utilisé, et certaines personnes déconseillent l’utilisent. Mais c'est utile pour les personnes qui viennent à numpy de Matlab, et dans d'autres contextes. Je pensais l'inclure puisque nous parlons de matrices!
>>> numpy.matrix([[1, 2], [3, 4]])
matrix([[1, 2],
[3, 4]])
Voici d'autres manières de créer des tableaux et des matrices 2D (la sortie étant supprimée pour des raisons de compacité):
numpy.matrix('1 2; 3 4') # use Matlab-style syntax
numpy.arange(25).reshape((5, 5)) # create a 1-d range and reshape
numpy.array(range(25)).reshape((5, 5)) # pass a Python range and reshape
numpy.array([5] * 25).reshape((5, 5)) # pass a Python list and reshape
numpy.empty((5, 5)) # allocate, but don't initialize
numpy.ones((5, 5)) # initialize with ones
numpy.ndarray((5, 5)) # use the low-level constructor
Voici une notation plus courte pour initialiser une liste de listes:
matrix = [[0]*5 for i in range(5)]
Malheureusement, réduire ceci à quelque chose comme 5*[5*[0]] ne fonctionne pas vraiment car vous vous retrouvez avec 5 copies de la même liste. Ainsi, lorsque vous en modifiez une, elles changent toutes, par exemple:
>>> matrix = 5*[5*[0]]
>>> matrix
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
>>> matrix[4][4] = 2
>>> matrix
[[0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2]]
Si vous voulez créer une matrice vide, la syntaxe correcte est la suivante:
matrix = [[]]
Et si vous voulez générer une matrice de taille 5 remplie de 0,
matrix = [[0 for i in xrange(5)] for i in xrange(5)]
Si tout ce que vous voulez, c'est un conteneur bidimensionnel pouvant contenir certains éléments, vous pouvez facilement utiliser un dictionnaire:
Matrix = {}
Ensuite, vous pouvez faire:
Matrix[1,2] = 15
print Matrix[1,2]
Cela fonctionne parce que 1,2 est un tuple et que vous l'utilisez comme clé pour indexer le dictionnaire. Le résultat est similaire à une matrice maigre et clairsemée.
Comme indiqué par osa et Josap Valls, vous pouvez également utiliser Matrix = collections.defaultdict(lambda:0) pour que les éléments manquants aient une valeur par défaut de 0.
Vatsal ajoute que cette méthode n’est probablement pas très efficace pour les grandes matrices et ne doit être utilisée que dans des parties non critiques du code.
En Python, vous allez créer une liste de listes. Vous n'êtes pas obligé de déclarer les dimensions à l'avance, mais vous le pouvez. Par exemple:
matrix = []
matrix.append([])
matrix.append([])
matrix[0].append(2)
matrix[1].append(3)
Maintenant, matrice [0] [0] == 2 et matrice [1] [0] == 3. Vous pouvez également utiliser la syntaxe de compréhension de liste. Cet exemple l'utilise deux fois pour construire une "liste à deux dimensions":
from itertools import count, takewhile
matrix = [[i for i in takewhile(lambda j: j < (k+1) * 10, count(k*10))] for k in range(10)]
La réponse acceptée est bonne et correcte, mais il m'a fallu un certain temps pour comprendre que je pouvais aussi l'utiliser pour créer un tableau complètement vide.
l = [[] for _ in range(3)]
résulte en
[[], [], []]
Vous devriez faire une liste de listes, et le meilleur moyen est d'utiliser des compréhensions imbriquées:
>>> matrix = [[0 for i in range(5)] for j in range(5)]
>>> pprint.pprint(matrix)
[[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]]
Sur votre exemple [5][5], vous créez une liste avec un entier "5" à l'intérieur et essayez d'accéder à son 5ème élément, ce qui génère naturellement une IndexError car il n'y a pas de cinquième élément:
>>> l = [5]
>>> l[5]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
rows = int(input())
cols = int(input())
matrix = []
for i in range(rows):
row = []
for j in range(cols):
row.append(0)
matrix.append(row)
print(matrix)
Pourquoi un code si long, que vous demandez aussi dans Python?
Il y a longtemps que je n'étais pas à l'aise avec Python, j'ai vu les réponses à une seule ligne pour écrire une matrice 2D et je me suis dit que je n'allais plus utiliser la matrice à deux dimensions en Python. (Ces lignes simples étaient plutôt effrayantes et cela ne me donnait aucune information sur ce que faisait Python. Notez également que je ne suis pas au courant de ces raccourcis.)
Quoi qu'il en soit, voici le code pour un débutant dont les origines C, CPP et Java
Note aux amoureux et experts de Python: S'il vous plaît, ne votez pas simplement parce que j'ai écrit un code détaillé.
Pour déclarer une matrice de zéros (uns):
numpy.zeros((x, y))
par exemple.
>>> numpy.zeros((3, 5))
array([[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
ou numpy.ones ((x, y)) p. ex.
>>> np.ones((3, 5))
array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])
Même trois dimensions sont possibles . ( http://www.astro.ufl.edu/~warner/prog/python.html see -> Tableaux multidimensionnels)
Utilisation:
matrix = [[0]*5 for i in range(5)]
Le * 5 pour la première dimension fonctionne car à ce niveau les données sont immuables.
Une réécriture facile à lire:
# 2D array/ matrix
# 5 rows, 5 cols
rows_count = 5
cols_count = 5
# create
# creation looks reverse
# create an array of "cols_count" cols, for each of the "rows_count" rows
# all elements are initialized to 0
two_d_array = [[0 for j in range(cols_count)] for i in range(rows_count)]
# index is from 0 to 4
# for both rows & cols
# since 5 rows, 5 cols
# use
two_d_array[0][0] = 1
print two_d_array[0][0] # prints 1 # 1st row, 1st col (top-left element of matrix)
two_d_array[1][0] = 2
print two_d_array[1][0] # prints 2 # 2nd row, 1st col
two_d_array[1][4] = 3
print two_d_array[1][4] # prints 3 # 2nd row, last col
two_d_array[4][4] = 4
print two_d_array[4][4] # prints 4 # last row, last col (right, bottom element of matrix)
J'en suis à mon premier script Python, et l'exemple de la matrice carrée m'a quelque peu confus. J'espère que l'exemple ci-dessous vous aidera à gagner du temps:
# Creates a 2 x 5 matrix
Matrix = [[0 for y in xrange(5)] for x in xrange(2)]
pour que
Matrix[1][4] = 2 # Valid
Matrix[4][1] = 3 # IndexError: list index out of range
En utilisant NumPy, vous pouvez initialiser une matrice vide comme ceci:
import numpy as np
mm = np.matrix([])
Et plus tard, ajoutez des données comme ceci:
mm = np.append(mm, [[1,2]], axis=1)
C'est ainsi que je crée habituellement des tableaux 2D en python.
col = 3
row = 4
array = [[0] * col for _ in range(row)]
Je trouve cette syntaxe facile à retenir par rapport à l'utilisation de boucles for dans une liste de compréhension.
Je lis des fichiers séparés par des virgules comme ceci:
data=[]
for l in infile:
l = split(',')
data.append(l)
La liste "data" est alors une liste de listes avec index data [row] [col]
Si vous voulez pouvoir le penser comme un tableau 2D plutôt que d'être obligé de penser en termes de liste de listes (beaucoup plus naturel à mon avis), vous pouvez procéder comme suit:
import numpy
Nx=3; Ny=4
my2Dlist= numpy.zeros((Nx,Ny)).tolist()
Le résultat est une liste (et non un tableau NumPy), et vous pouvez écraser les positions individuelles avec des nombres, des chaînes, etc.
Utilisation:
import copy
def ndlist(*args, init=0):
dp = init
for x in reversed(args):
dp = [copy.deepcopy(dp) for _ in range(x)]
return dp
l = ndlist(1,2,3,4) # 4 dimensional list initialized with 0's
l[0][1][2][3] = 1
Je pense que NumPy est la voie à suivre. Ce qui précède est un générique si vous ne voulez pas utiliser NumPy.
# Creates a list containing 5 lists initialized to 0
Matrix = [[0]*5]*5
Faites attention à cette courte expression, voir l'explication complète dans la réponse de @FJ
C'est ce que dictionary est fait pour!
matrix = {}
Vous pouvez définir clés et valeurs de deux manières:
matrix[0,0] = value
ou
matrix = { (0,0) : value }
Résultat:
[ value, value, value, value, value],
[ value, value, value, value, value],
...
Si vous n'avez pas les informations de taille avant de commencer, créez deux listes unidimensionnelles.
liste 1: pour stocker les lignes liste 2: matrice bidimensionnelle réelle
Stockez la ligne entière dans la 1ère liste. Une fois cela fait, ajoutez la liste 1 à la liste 2:
from random import randint
coordinates=[]
temp=[]
points=int(raw_input("Enter No Of Coordinates >"))
for i in range(0,points):
randomx=randint(0,1000)
randomy=randint(0,1000)
temp=[]
temp.append(randomx)
temp.append(randomy)
coordinates.append(temp)
print coordinates
Sortie:
Enter No Of Coordinates >4
[[522, 96], [378, 276], [349, 741], [238, 439]]
en utilisant la liste:
matrix_in_python = [['Roy',80,75,85,90,95],['John',75,80,75,85,100],['Dave',80,80,80,90,95]]
en utilisant dict: vous pouvez également stocker ces informations dans la table de hachage pour une recherche rapide
matrix = { '1':[0,0] , '2':[0,1],'3':[0,2],'4' : [1,0],'5':[1,1],'6':[1,2],'7':[2,0],'8':[2,1],'9':[2,2]};
la matrice ['1'] vous donnera le résultat en O(1) temps
* nb : vous devez gérer une collision dans la table de hachage
Vous pouvez créer une liste bidimensionnelle vide en imbriquant deux croisillons ou trois crochets ([], séparés par une virgule) ou plus, avec un croisillon, comme ci-dessous:
Matrix = [[], []]
Supposons maintenant que vous vouliez ajouter 1 à Matrix[0][0] puis vous tapez:
Matrix[0].append(1)
Maintenant, tapez Matrix et appuyez sur Entrée. La sortie sera:
[[1], []]
l=[[0]*(L) for i in range(W)]
Sera plus rapide que:
l = [[0 for x in range(L)] for y in range(W)]
Si vous avez besoin d’une matrice avec des nombres prédéfinis, vous pouvez utiliser le code suivant:
def matrix(rows, cols, start=0):
return [[c + start + r * cols for c in range(cols)] for r in range(rows)]
assert matrix(2, 3, 1) == [[1, 2, 3], [4, 5, 6]]
Essaye ça:
rows = int(input('Enter rows\n'))
my_list = []
for i in range(rows):
my_list.append(list(map(int, input().split())))