Fügen Sie zwei Matrizen in python

Matrix-Bibliothek

Können Sie die numpy - Modul, die Unterstützung für diese.

>>> import numpy as np

>>> a = np.matrix([[1, 2], [3, 4]])
>>> b = np.matrix([[2, 2], [2, 2]])

>>> a+b
matrix([[3, 4],
        [5, 6]])

Home-grown-Lösung: Schwergewicht

Vorausgesetzt, Sie wollte es selbst implementieren, würde man die Einrichtung der folgenden Maschinen, die ermöglichen würden Sie definieren beliebige paarweise Operationen:

from pprint import pformat as pf

class Matrix(object):
    def __init__(self, arrayOfRows=None, rows=None, cols=None):
        if arrayOfRows:
            self.data = arrayOfRows
        else:
            self.data = [[0 for c in range(cols)] for r in range(rows)]
        self.rows = len(self.data)
        self.cols = len(self.data[0])

    @property
    def shape(self):          # myMatrix.shape -> (4,3)
        return (self.rows, self.cols)
    def __getitem__(self, i): # lets you do myMatrix[row][col
        return self.data[i]
    def __str__(self):        # pretty string formatting
        return pf(self.data)

    @classmethod
    def map(cls, func, *matrices):
        assert len(set(m.shape for m in matrices))==1, 'Not all matrices same shape'

        rows,cols = matrices[0].shape
        new = Matrix(rows=rows, cols=cols)
        for r in range(rows):
            for c in range(cols):
                new[r][c] = func(*[m[r][c] for m in matrices], r=r, c=c)
        return new

Nun hinzufügen paarweise Methoden ist so einfach wie überzeugend:

    def __add__(self, other):
        return Matrix.map(lambda a,b,**kw:a+b, self, other)
    def __sub__(self, other):
        return Matrix.map(lambda a,b,**kw:a-b, self, other)

Beispiel:

>>> a = Matrix([[1, 2], [3, 4]])
>>> b = Matrix([[2, 2], [2, 2]])
>>> b = Matrix([[0, 0], [0, 0]])

>>> print(a+b)
[[3, 4], [5, 6]]                                                                                                                                                                                                      

>>> print(a-b)
[[-1, 0], [1, 2]]

Können Sie sogar paarweise Errichtung in die Stufe, die negation, die binären Operationen, etc. Ich nicht zeigen es hier, weil es wahrscheinlich am besten, lassen * und ** für die matrix-Multiplikation und matrix-Potenzierung.

Home-grown-Lösung: leichte

Wenn Sie wollen einfach nur eine wirklich einfache Methode zum zuordnen einer Bedienung über nur zwei verschachtelte-Liste-Matrizen, können Sie dies tun:

def listmatrixMap(f, *matrices):
    return \
        [
            [
                f(*values) 
                for c,values in enumerate(zip(*rows))
            ] 
            for r,rows in enumerate(zip(*matrices))
        ]

Demo:

>>> listmatrixMap(operator.add, a, b, c))
[[3, 4], [5, 6]]

Mit einer zusätzlichen if-else-und keyword-argument verwenden, können Sie Indizes, die in Ihren lambda. Unten ist ein Beispiel, wie man ein matrix-Reihe-um enumerate Funktion. Die if-else-und-Schlüsselwort ausgelassen wurden, die oben für Klarheit.

>>> listmatrixMap(lambda val,r,c:((r,c),val), a, indices=True)
[[((0, 0), 1), ((0, 1), 2)], [((1, 0), 3), ((1, 1), 4)]]

Bearbeiten

So könnten wir schreiben die obige add_matrices Funktion etwa so:

def add_matrices(a,b):
    return listmatrixMap(add, a, b)

Demo:

>>> add_matrices(c, d)
[[11, 4], [12, 6], [15, 19]]

InformationsquelleAutor ninjagecko

from itertools import izip

def add_matrices(c, d):
    return [[a+b for a, b in izip(row1, row2)] for row1, row2 in izip(c, d)]

Aber wie oben schon gesagt, gibt es keine Notwendigkeit, das Rad neu zu erfinden, verwenden Sie einfach numpy, die ist wahrscheinlich schneller und flexibler.

InformationsquelleAutor Tamás