3 Möglichkeiten, Matrizen in Python zu multiplizieren

In diesem Tutorial erfahren Sie, wie es geht zwei Matrizen multiplizieren bei Python.

Sie lernen zunächst die Bedingung für eine gültige Matrizenmultiplikation und schreiben eine benutzerdefinierte Python-Funktion zum Multiplizieren von Matrizen. Als Nächstes werden Sie sehen, wie Sie dasselbe Ergebnis mit verschachtelten Listenverständnissen erzielen können.

Finally, Sie werden mit der Verwendung fortfahren NumPy und seine eingebauten Funktionen, um die Matrixmultiplikation effizienter durchzuführen.

So prüfen Sie, ob die Matrixmultiplikation gültig ist

Bevor wir Python-Code für die Matrixmultiplikation schreiben, lesen wir revLernen Sie die Grundlagen der Matrixmultiplikation kennen.

Matrixmultiplikation zwischen zwei Matrizen A und B ist nur gültig, wenn die Anzahl der Spalten in Matrix A is gleich zu den Anzahl der rows in Matrix B.

Wahrscheinlich sind Sie dieser Bedingung für die Matrixmultiplikation schon einmal begegnet. Haben Sie sich jedoch jemals gefragt, warum dies so ist?

Nun, das liegt an der Art und Weise, wie die Matrixmultiplikation funktioniert. Schauen Sie sich das Bild unten an.

In unserem allgemeinen Beispiel hat Matrix A m rows und n Säulen. Und Matrix B hat n rows und p Säulen.

Welche Form hat die Produktmatrix?

Das Element am Index (i, j) in der resultierenden Matrix C ist das Skalarprodukt der Zeile i der Matrix A und der Spalte j der Matrix B.

Um also ein Element an einem bestimmten Index in der resultierenden Matrix C zu erhalten, müssen Sie das Skalarprodukt der entsprechenden Zeile und Spalte in den Matrizen A bzw. B berechnen.

Wiederholen der process Oben erhalten Sie die Produktmatrix C der Form mxp-mit m rows und p Spalten, wie unten gezeigt.

Und das Skalarprodukt oder das Skalarprodukt zwischen zwei Vektoren a und b ist durch die folgende Gleichung gegeben.

Fassen wir jetzt zusammen:

• Es ist offensichtlich, dass das Skalarprodukt nur zwischen Vektoren gleicher Länge definiert ist.
• Damit also das Skalarprodukt zwischen einer Zeile und einer Spalte gültig ist – wenn Sie zwei Matrizen multiplizieren – müssten beide die gleiche Anzahl von Elementen haben.
• Im obigen allgemeinen Beispiel hat jede Zeile in Matrix A n Elemente. Und jede Spalte in Matrix B hat n Elemente auch.

Schaut man genauer hin, n is the number of columns in matrix A, and it’s also the number of rows in matrix B. And this is precisely the reason why you need the Anzahl der Spalten in Matrix A sein gleich zu den Anzahl der rows in Matrix B.

Ich hoffe, Sie verstehen, dass die Bedingung für die Matrixmultiplikation gültig ist und wie Sie jedes Element in der Produktmatrix erhalten.

Lassen Sie uns damit fortfahren, Python-Code zu schreiben, um zwei Matrizen zu multiplizieren.

Schreiben Sie eine benutzerdefinierte Python-Funktion zum Multiplizieren von Matrizen

Lassen Sie uns als ersten Schritt eine benutzerdefinierte Funktion schreiben, um Matrizen zu multiplizieren.

Diese Funktion sollte Folgendes tun:

• Akzeptieren Sie zwei Matrizen, A und B, als Eingaben.
• Prüfen Sie, ob die Matrixmultiplikation zwischen A und B gültig ist.
• Falls gültig, multiplizieren Sie die beiden Matrizen A und B und geben Sie die Produktmatrix C zurück.
• Anderenfalls wird eine Fehlermeldung zurückgegeben, dass die Matrizen A und B nicht multipliziert werden können.

Schritt 1: Generate zwei Matrizen ganzer Zahlen mit NumPy random.randint() Funktion. Sie können Matrizen auch als verschachtelte Python-Listen deklarieren.

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

Schritt 2: Gehen Sie voran und definieren Sie die Funktion multiply_matrix(A,B). Diese Funktion übernimmt zwei Matrizen A und B als Eingaben und gibt die Produktmatrix zurück C wenn die Matrixmultiplikation gültig ist.

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

Analysieren der Funktionsdefinition

Lassen Sie uns mit dem Analysieren der Funktionsdefinition fortfahren.

Deklarieren Sie C als globale Variable: Standardmäßig haben alle Variablen innerhalb einer Python-Funktion einen lokalen Geltungsbereich. Und Sie können von außerhalb der Funktion nicht darauf zugreifen. Um die Produktmatrix C von außen zugänglich zu machen, müssen wir sie als globale Variable deklarieren. Fügen Sie einfach die hinzu global Qualifizierer vor dem Variablennamen.

Überprüfen Sie, ob die Matrixmultiplikation gültig ist: Verwenden Sie das shape Attribut, um zu prüfen, ob A und B multipliziert werden können. Für jedes Array arr, arr.shape[0] und arr.shape[1] gib die Nummer an rows und Säulen, bzw. So if A.shape[1] == B.shape[0] prüft, ob die Matrixmultiplikation gültig ist. Nur wenn dieser Zustand vorliegt True, wird die Produktmatrix berechnet. Andernfalls gibt die Funktion eine Fehlermeldung zurück.

Verwenden Sie verschachtelte Schleifen, um Werte zu berechnen: To compute the elements of the resultant matrix, we have to loop through the rows of matrix A, and the outer for Schleife tut dies. Das Innere for Schleife hilft uns, die Spalte von Matrix B zu durchlaufen. Und die innerste for Schleife hilft beim Zugriff auf jedes Element in der ausgewählten Spalte.

▶️ Nachdem wir nun gelernt haben, wie die Python-Funktion zum Multiplizieren von Matrizen funktioniert, rufen wir die Funktion mit den Matrizen A und B auf, die wir generierenated früher.

multiply_matrix(A,B)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

Als Matrixmultiplikation zwischen A und B gilt die Funktion multiply_matrix() gibt die Produktmatrix C zurück.

Verwenden Sie Python Nested List Comprehension, um Matrizen zu multiplizieren

In der prevIn diesem Abschnitt haben Sie eine Python-Funktion zum Multiplizieren von Matrizen geschrieben. Jetzt werden Sie sehen, wie Sie verschachtelte Listenverständnisse verwenden können, um dasselbe zu erreichen.

Hier ist das Verständnis der verschachtelten Liste zum Multiplizieren von Matrizen.

Auf den ersten Blick mag das kompliziert erscheinenateD. Aber wir werden das Verständnis verschachtelter Listen Schritt für Schritt analysieren.

Konzentrieren wir uns jeweils auf ein Listenverständnis und identifizieren, was es bewirkt.

Wir verwenden die folgende allgemeine Vorlageate Zum Listenverständnis:

[<do-this> for <item> in <iterable>]

where,
<do-this>: what you'd like to do—expression or operation
<item>: each item you'd like to perform the operation on
<iterable>: the iterable (list, tuple, etc.) that you're looping through

▶️ Schau dir unseren Ratgeber an Listenverständnis in Python – mit Beispielen um ein tiefes Verständnis zu erlangen.

Bevor Sie fortfahren, beachten Sie bitte, dass wir die resultierende Matrix C erstellen möchten eine Reihe zu einem Zeitpunkt.

Verschachteltes Listenverständnis erklärt

Schritt 1: Berechnen Sie einen einzelnen Wert in der Matrix C

Bei gegebener Zeile i von Matrix A und Spalte j von Matrix B ergibt der folgende Ausdruck den Eintrag am Index (i, j) in Matrix C.

sum(a*b for a,b in zip(A_row, B_col)

# zip(A_row, B_col) returns an iterator of tuples
# If A_row = [a1, a2, a3] & B_col = [b1, b2, b3]
# zip(A_row, B_col) returns (a1, b1), (a2, b2), and so on

If i = j = 1, gibt der Ausdruck den Eintrag zurück c_11 der Matrix C. Auf diese Weise können Sie also ein Element in einer Zeile erhalten.

Schritt 2: Bilden Sie eine Zeile in der Matrix C

Unser nächstes Ziel ist es, eine ganze Reihe zu bauen.

Für Zeile 1 in Matrix A müssen Sie alle Spalten in Matrix B durchlaufen, um eine vollständige Zeile in Matrix C zu erhalten.

Gehen Sie zurück zur Listenverständnis-Vorlageate.

• Ersetzen <do-this> mit dem Ausdruck aus Schritt 1, denn das möchten Sie tun.
• Als nächstes ersetzen <item> mit B_col– jede Spalte in Matrix B.
• Finallyersetzen <iterable> mit zip(*B)— die Liste, die alle Spalten in Matrix B enthält.

Und hier ist das erste Listenverständnis.

[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)] 

# zip(*B): * is the unzipping operator
# zip(*B) returns a list of columns in matrix B

Schritt 3: Alles bauen rows and obtain the matrix C

Als nächstes müssen Sie füllenate the product matrix C by computing the rest of the rows.

And for this, you’ve to loop through all rows in matrix A.

Gehen Sie noch einmal zurück zum Listenverständnis und gehen Sie wie folgt vor.

• Ersetzen <do-this> mit dem Listenverständnis aus Schritt 2. Denken Sie daran, dass wir eine ganze Zeile im p berechnet habenrevSchritt.
• Jetzt ersetzen <item> mit A_row– jede Zeile in Matrix A.
• Und dein <iterable> is the matrix A itself, as you’re looping through its rows.

Und hier ist unser letztes Verständnis der verschachtelten Liste.🎊

[[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)] 
    for A_row in A]

Es ist Zeit, das Ergebnis zu überprüfen! ✔

# cast into <a href="https://geekflare.com/numpy-reshape-arrays-in-python/">NumPy array</a> using np.array()
C = np.array([[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)] 
    for A_row in A])

# Output:
[[ 89 107]
 [ 47  49]
 [ 40  44]]

Wenn Sie genauer hinsehen, entspricht dies den verschachtelten for-Schleifen, die wir zuvor hatten – nur dass es prägnanter ist.

Sie können dies auch noch effizienter tun, indem Sie einige eingebaute Funktionen verwenden. Lassen Sie uns im nächsten Abschnitt mehr über sie erfahren.

Verwenden Sie NumPy matmul(), um Matrizen in Python zu multiplizieren

Der np.matmul() nimmt zwei Matrizen als Eingabe und gibt das Produkt zurück, wenn eine Matrixmultiplikation zwischen den Eingabematrizen erfolgt gültig.

C = np.matmul(A,B)
print(C)

# Output:
[[ 89 107]
 [ 47  49]
 [ 40  44]]

Beachten Sie, dass diese Methode einfacher ist als die beiden zuvor erlernten Methoden. Eigentlich statt np.matmul(), können Sie einen äquivalenten @-Operator verwenden, und wir werden das gleich sehen.

So verwenden Sie den @-Operator in Python, um Matrizen zu multiplizieren

In Python @ ist ein binärer Operator, der für die Matrixmultiplikation verwendet wird.

Es ist in Betriebates für zwei Matrizen und im Allgemeinen N-dimensionale NumPy-Arrays und gibt die Produktmatrix zurück.

Hinweis: Sie benötigen Python 3.5 und later, um das zu verwenden @ Betreiber.

Hier erfahren Sie, wie Sie es verwenden können.

C = A@B
print(C)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

Beachten Sie, dass die Produktmatrix C die gleiche ist wie die, die wir zuvor erhalten haben.

Können Sie np.dot() verwenden, um Matrizen zu multiplizieren?

Wenn Sie jemals auf Code gestoßen sind, der verwendet np.dot() Um zwei Matrizen zu multiplizieren, funktioniert es so.

C = np.dot(A,B)
print(C)

# Output:
[[ 89 107]
 [ 47  49]
 [ 40  44]]

Das wirst du sehen np.dot(A, B) gibt auch die erwartete Produktmatrix zurück.

Jedoch gemäß NumPy-Dokumente, du solltest benutzen np.dot() nur zur Berechnung des Skalarprodukts zweier eindimensionaler Vektoren und nicht zur Matrixmultiplikation.

Rückruf vom SrevIn diesem Abschnitt ist das Element am Index (i, j) der Produktmatrix C das Skalarprodukt der Zeile i der Matrix A und der Spalte j der Matrix B.

As NumPy implicitly broadcasts this dot product operation to all rows and all columns, you get the resultant product matrix. But to keep your code readable and avoid ambiguity, use np.matmul() oder im @ Betreiber statt.

Schlussfolgerung

🎯 In diesem Tutorial haben Sie Folgendes gelernt.

• Bedingung für eine gültige Matrixmultiplikation: Anzahl von Spalten in Matrix A = Anzahl von rows in Matrix B.
• So schreiben Sie eine benutzerdefinierte Python-Funktion, die prüft, ob die Matrixmultiplikation gültig ist, und die Produktmatrix zurückgibt. Der Hauptteil der Funktion verwendet verschachtelte for-Schleifen.
• Als Nächstes haben Sie gelernt, wie Sie verschachtelte Listen verwenden, um Matrizen zu multiplizieren. Sie sind prägnanter als for-Schleifen, neigen aber zu Lesbarkeitsproblemen.
• Finally, haben Sie gelernt, die in NumPy integrierte Funktion np.matmul() zum Multiplizieren von Matrizen zu verwenden und wie dies im Hinblick auf die Geschwindigkeit am effizientesten ist.
• Sie haben auch etwas über die gelernt @ Operator zum Multiplizieren zweier Matrizen in Python.

Und damit endet unsere Diskussion über die Matrixmultiplikation in Python. Als nächsten Schritt erfahren Sie, wie Sie prüfen, ob a Zahl ist in Python eine Primzahl. Oder interessant lösen Probleme mit Python-Strings.

Viel Spaß beim Lernen!🎉