Si vous voulez vraiment une matrice, vous feriez mieux d'utiliser numpy. Les opérations matricielles dans numpy utilisent le plus souvent un type de tableau à deux dimensions. Il y a 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 recommandent de ne pas l'utiliser. 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 quelques autres façons de créer des tableaux 2d et matrices (avec sortie retiré 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, raccourcir cela à quelque chose comme 5*[5*[0]] ne fonctionne pas vraiment parce que vous vous retrouvez avec 5 copies de la même Liste, donc lorsque vous modifiez l'une d'entre elles, 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 souhaitez créer une matrice vide, la syntaxe correcte est

matrix = [[]]

Et si vous voulez générer une matrice de taille 5 rempli de 0,

matrix = [[0 for i in xrange(5)] for i in xrange(5)]

Si tout ce que vous voulez est un conteneur à deux dimensions pour contenir certains éléments, vous pouvez facilement utiliser un dictionnaire à la place:

Matrix = {}

, Alors vous pouvez faire:

Matrix[1,2] = 15
print Matrix[1,2]

Cela fonctionne parce que 1,2 est un tuple, et vous l'utilisez comme clé pour indexer le dictionnaire. Le résultat est similaire à une matrice muette 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 indique en outre que cette méthode n'est probablement pas très efficace pour les grandes matrices et ne devrait être utilisé que dans les parties non critiques du code.

En Python, vous allez créer une liste de listes. Vous n'avez pas à déclarer les dimensions à l'avance, mais vous pouvez. Par exemple:

matrix = []
matrix.append([])
matrix.append([])
matrix[0].append(2)
matrix[1].append(3)

Maintenant matrice[0][0] == 2 et la 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ésultats dans

[[], [], []]

Vous devriez faire une liste de listes, et la meilleure façon 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 soulève naturellement une IndexError car il n'y a pas de 5ème élément:

>>> l = [5]
>>> l[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

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.ceux((x, y)) par exemple

>>> 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 Voir -- > tableaux multidimensionnels)

Une réécriture pour en faciliter la lecture:

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

Je suis sur mon premier script Python, et j'étais un peu confus par l'exemple de matrice carrée, donc 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)]

De sorte que

Matrix[1][4] = 2 # Valid
Matrix[4][1] = 3 # IndexError: list index out of range

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.

En utilisant NumPy, vous pouvez initialiser la matrice vide comme ceci:

import numpy as np
mm = np.matrix([])

Et plus tard ajouter des données comme ceci:

mm = np.append(mm, [[1,2]], axis=1)

Je lis dans des fichiers séparés par des virgules comme ceci:

data=[]
for l in infile:
    l = split(',')
    data.append(l)

La liste des "données" est alors une liste de listes de données d'index[row][col]

# Creates a list containing 5 lists initialized to 0
Matrix = [[0]*5]*5

Faites attention à cette expression courte, voir l'explication complète dans la réponse de @ F. J

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 générique si vous ne voulez pas utiliser NumPy.

C'est ce Que dictionnaire est fait pour!

matrix = {}

, Vous pouvez définir keys et valeurs de deux façons:

matrix[0,0] = value

Ou

matrix = { (0,0)  : value }

Résultat:

   [ value,  value,  value,  value,  value],
   [ value,  value,  value,  value,  value],
   ...

Si vous voulez être capable de le penser comme un tableau 2D plutôt que d'être forcé de penser en termes de liste de listes (beaucoup plus naturel à mon avis), vous pouvez faire ce qui suit:

import numpy
Nx=3; Ny=4
my2Dlist= numpy.zeros((Nx,Ny)).tolist()

Le résultat est une Liste (pas un tableau NumPy), et vous pouvez écraser les positions individuelles avec des nombres, des chaînes, peu importe.

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 trop dans Python vous demandez?

Longtemps quand 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 ne vais plus utiliser la matrice 2-D en Python. (Ces lignes simples étaient assez effrayantes et cela ne m'a donné 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 qui vient de C, CPP et Java contexte

Note aux amateurs de Python et aux Experts: veuillez ne pas voter simplement parce que j'ai écrit un code détaillé.

Si vous n'avez pas d'informations de taille avant de commencer, créez deux listes unidimensionnelles.

Liste 1: pour stocker les lignes liste 2: matrice bidimensionnelle réelle

Stocke la ligne entière dans la 1ère liste. Une fois terminé, 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 list:

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 comme

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]};

De la Matrice['1'] vous donnera le résultat en O(1) temps

*nb : vous devez gérer une collision dans la table de hachage

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 compréhension de liste.