Comment ajouter des tableaux bidimensionnels coin à coin

Question

Question:

J'ai n tableaux carrés bidimensionnels de commande arbitraire. Pour simplifier, disons que j'ai 3 tableaux bidimensionnels A, B, C avec des commandes 3×3, 4×4, 2×2 respectivement. Ici :

   [[a a a]      [[b b b b]     [[c c]  
A=  [a a a]  ,B=  [b b b b] ,C=  [c c]]
    [a a a]]      [b b b b]
                  [b b b b]

Je sais que pour les tableaux bidimensionnels avec le même nombre de lignes, nous pouvons les appendre très facilement (en ajoutant les colonnes côte à côte), mais même si ces tableaux avaient le même nombre de lignes, je ne veux pas les appendre côte à côte mais je veux créer à partir de ces 3 tableaux un autre tableau bidimensionnel carré de commande 3+4+2=9, c'est-à-dire, un tableau 9×9, disons, coll_array. Ici :

            [[a a a 0 0 0 0 0 0]
             [a a a 0 0 0 0 0 0]
             [a a a 0 0 0 0 0 0]
             [0 0 0 b b b b 0 0]
coll_array=  [0 0 0 b b b b 0 0]
             [0 0 0 b b b b 0 0]
             [0 0 0 b b b b 0 0]
             [0 0 0 0 0 0 0 c c]
             [0 0 0 0 0 0 0 c c]]

Veuillez regarder attentivement le tableau ci-dessus. Je sais que ce n'est pas une appendre mais Je ne viens pas de l'informatique, je ne sais pas comment cela peut être appelé. Je suis essentiellement en train d'insérer les éléments de ces 3 tableaux dans ce tableau collectif.

Ce que j'ai essayé:

T = len(A)+len(B)+len(C)

Je sais que je peux d'abord initialiser un tableau bidimensionnel T×T :

coll_array=np.array([[0]*T]*T).reshape(T,T)
for i in range(T):
    for j in range(T):
        if (i< len(A)) and (j=len(A)) and (j>=len(A)) and (i=len(A)+len(B)) and (j>=len(A)+len(B)) and (i

``

Oui cela fonctionnerait, mais le problème est que je n'ai pas seulement 3 tableaux carrés bidimensionnels à combiner mais j'en ai n nombre et n pourrait être très grand, pour lequel j'ai besoin d'écrire n-1 déclarations elif, nécessitant une boucle ou quelque chose. Je peux créer des variables globales dynamiques comme lensum1 pour len(A), lensum2 pour len(A)+len(B), lensum10 pour len(A)+len(B)+...+ len(L). Ce n'est pas un problème, mais écrire automatiquement ces nombreuses instructions elif est la tâche principale.

Note: Je n'ai pas ces noms de tableaux A, B, C, etc. Mais j'ai un autre tableau de ces tableaux comme ceci : ind_array= [A B C . . .] et je pourrais avoir besoin d'assigner un nom de variable globale à ces tableaux comme A1, A2, etc. si nécessaire, mais il serait préférable de pouvoir les appeler directement en utilisant ind_array[0], ind_array[1] etc.

À propos de l'efficacité:

Je n'aimerais bien sûr pas que mon programme vérifie autant de conditions if-elif pour chaque (i,j), donc une méthode pour appendre ces tableaux coin à coin est ce dont j'ai besoin ou tout autre programme efficient qui peut accomplir cette tâche.

Merci. Toute aide sera appréciée.

Demande : Veuillez ne pas marquer ceci comme hors-sujet ou fermer avant que je reçoive de l'aide.

``

Answer 1

Vous recherchez scipy.linalg.block_diag:

import numpy as np
from scipy.linalg import block_diag

a = np.full((3,3), "a")
b = np.full((4,4), "b")
c = np.full((2,2), "c")

block_diag(a, b, c)
# or block_diag(*[list_or_arrays])

Ou rendre la longueur variable du tableau carré (comme indiqué dans le commentaire):

ind_array = ["a", "b", "c"]
shape_array = [3, 4, 2]

block_diag(*[np.full((i, i), c) for c, i in zip(ind_array, shape_array)])

Sortie:

array([['a', 'a', 'a', 0, 0, 0, 0, 0, 0],
       ['a', 'a', 'a', 0, 0, 0, 0, 0, 0],
       ['a', 'a', 'a', 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 'b', 'b', 'b', 'b', 0, 0],
       [0, 0, 0, 'b', 'b', 'b', 'b', 0, 0],
       [0, 0, 0, 'b', 'b', 'b', 'b', 0, 0],
       [0, 0, 0, 'b', 'b', 'b', 'b', 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 'c', 'c'],
       [0, 0, 0, 0, 0, 0, 0, 'c', 'c']], dtype=object)