Comment créer une matrice à travers une itération en Python

Question

Je veux créer une matrice (3n * 7) en python par Iteration, je l'ai fait dans VB.Net et cela a fonctionné, mais cela me pose un certain défi en Python nouvelle langue pour moi. n peut être le nombre d'itérations pour construire la matrice, c'est-à-dire; si vous itérez 3 fois, la matrice sera une matrice 9 * 7. Voici comment je l'ai fait dans VB.Net. :

'Assign some values to the A matrix 
A_mat(p, 0) = 1 : A_mat(1 + p, 1) = 1 : A_mat(2 + p, 2) = 1 'row/column 1,2 & 3 data 
A_mat(p, 3) = c : A_mat(p, 4) = 0 : A_mat(p, 5) = a : A_mat(p, 6) = b 'row 1 data 
A_mat(1 + p, 3) = g : A_mat(1 + p, 4) = d : A_mat(1 + p, 5) = t : A_mat(1 + p, 6) = f 'row 2 data 
A_mat(2 + p, 3) = m : A_mat(2 + p, 4) = h : A_mat(2 + p, 5) = u : A_mat(2 + p, 6) = k 'row 3 data 

this yielded: 
1  0 0 c 0 a b 
0  1 0 g d t f 
0  0 1 m h u k 
.  . 
.   . 
.    . 

Answer 1

In [13]: [[0]*8 for el in range(8)] 
Out[13]: 
[[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, 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, 0, 0, 0, 0, 0, 0], 
[0, 0, 0, 0, 0, 0, 0, 0]] 

Ou même,

In [21]: [[a for a in range(el*8,(el+1)*8)] for el in range(8)] 
Out[21]: 
[[0, 1, 2, 3, 4, 5, 6, 7], 
[8, 9, 10, 11, 12, 13, 14, 15], 
[16, 17, 18, 19, 20, 21, 22, 23], 
[24, 25, 26, 27, 28, 29, 30, 31], 
[32, 33, 34, 35, 36, 37, 38, 39], 
[40, 41, 42, 43, 44, 45, 46, 47], 
[48, 49, 50, 51, 52, 53, 54, 55], 
[56, 57, 58, 59, 60, 61, 62, 63]] 

Answer 2

Votre question est marqué Numpy, si elle est ici sous une forme qui vous permet de le transformer en une matrice Numpy.

from numpy import matrix 

repeat = 3 
width = 7 
rows_per_iteration = 3 

# The 1st row is also the 4th and 7th, the 2nd is also the 5th and 8th, etc. 
A = [[0] * width for Null in range(rows_per_iteration)] * repeat 

A[0][0] = 1 
A[1][1] = 1 
A[2][2] = 1 
A[0][3] = 'c' 
A[0][4] = 0 
A[0][5] = 'a' 
A[0][6] = 'b' 
A[1][3] = 'g' 
A[1][4] = 'd' 
A[1][5] = 't' 
A[1][6] = 'f' 
A[2][3] = 'm' 
A[2][4] = 'h' 
A[2][5] = 'u' 
A[2][6] = 'k' 

A_mat = matrix(A) 

Si vous allez les utiliser sans passer à une matrice,

repeat = 3 
width = 7 
rows_per_iteration = 3 
total_rows = repeat * rows_per_iteration 

A = [[0] * width for Null in range(total_rows)] 

for np in range(0, total_rows, rows_per_iteration): 
    A[np][0] = 1 
    A[1 + np][1] = 1 
    A[2 + np][2] = 1 
    A[np][3] = 'c' 
    A[np][4] = 0 
    A[np][5] = 'a' 
    A[np][6] = 'b' 
    A[1 + np][3] = 'g' 
    A[1 + np][4] = 'd' 
    A[1 + np][5] = 't' 
    A[1 + np][6] = 'f' 
    A[2 + np][3] = 'm' 
    A[2 + np][4] = 'h' 
    A[2 + np][5] = 'u' 
    A[2 + np][6] = 'k' 

Ce qui va réellement créer des listes uniques pour chaque ligne au lieu de les réutiliser tous les 3 rangs.

Answer 3

Une solution consiste à utiliser un numpy (download here) matrix:

>>> from numpy import zeros, matrix 
>>> n = 2 
>>> mat = matrix(zeros([3*n, 7])) 
>>> mat 
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., 0., 0., 0.], 
     [ 0., 0., 0., 0., 0., 0., 0.], 
     [ 0., 0., 0., 0., 0., 0., 0.]]) 

Cependant, comme il est indiqué ci-dessus par @joris, avec une matrice numpy toutes vos données doivent être du même type.

>>> mat[0,2] = 14 
>>> mat 
matrix([[ 0., 0., 14., 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.], 
     [ 0., 0., 0., 0., 0., 0., 0.], 
     [ 0., 0., 0., 0., 0., 0., 0.]]) 
>>> mat[0,1] = 's' 

Traceback (most recent call last): 
    File "<pyshell#139>", line 1, in <module> 
    mat[0,1] = 's' 
ValueError: could not convert string to float: s 

Vous voulez probablement utiliser une place list imbriquée, puisque cela est loin d'être un type de données plus souple et générique, et en plus est plus facile d'obtenir le coup de. Pour cela, je vous renvoie à this question, puisque @Mike Graham fait un bon travail pour les expliquer. Vous pouvez définir une méthode comme:

def shape_zeros(n): 
    # Here's where you build up your "matrix"-style nested list 
    pass # The pass statement does nothing! 

Voici quelques conseils pour remplir le corps de code de la fonction ci-dessus. D'abord, vous pouvez construire une liste complète des doublons avec l'opérateur astérisque *:

>>> row = [0] * 7 
>>> row 
[0, 0, 0, 0, 0, 0, 0] 

Ensuite, vous pouvez les listes des nids dans les listes; mais faites attention lors du déplacement des listes autour, comme le nom de la liste est en fait comme un pointeur:

>>> mat = [] 
>>> n = 2 
>>> for i in range(n*3): 
    mat.append(row) 

>>> mat 
[[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, 0, 0, 0], 
[0, 0, 0, 0, 0, 0, 0], 
[0, 0, 0, 0, 0, 0, 0]] 
>>> mat[0][0] = 1 
>>> mat 
[[1, 0, 0, 0, 0, 0, 0], 
[1, 0, 0, 0, 0, 0, 0], 
[1, 0, 0, 0, 0, 0, 0], 
[1, 0, 0, 0, 0, 0, 0], 
[1, 0, 0, 0, 0, 0, 0], 
[1, 0, 0, 0, 0, 0, 0]] 

Vous pouvez éviter le problème ci-dessus en créant vos sous-listes (lignes) séparément ou en utilisant une fonction constructeur list(old_list) pour faire une copie. Lorsque vous le créez correctement, vous pouvez accéder/manipuler un élément d'une liste imbriquée comme ceci:

>>> mat[0][0] = 1 
>>> mat[1][2] = 'Q_Q' 
>>> mat[2][0] = 3 
>>> mat[2][2] = 5 
>>> mat 
[[1, 0, 0, 0, 0, 0, 0], 
[0, 0, 'Q_Q', 0, 0, 0, 0], 
[3, 0, 5, 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]] 

Bonne chance!