Vergleich der Matrixtranspositionsgeschwindigkeit durch Python

1. Hintergrund

Ich wollte ein zweidimensionales Array (Translokationsmatrix) ** mit Zeilen und Spalten erhalten, die von einem zweidimensionalen Array basierend auf dem Python-Standardlistentyp ** ausgetauscht wurden, weil mein Code extrem langsam war **, was die Transpositionsmatrixmethode ist Ich habe mich gefragt, ob es das schnellste ist, also habe ich es verglichen.

Matrix-Wikipedia übertragen

Da der Autor ein Anfänger mit weniger als einem halben Jahr Programmiererfahrung ist, würde ich es begrüßen, wenn Sie auf Fehler oder Verbesserungsmethoden hinweisen könnten. [** Zum Geschwindigkeitsvergleichsergebnis **](# 5-Geschwindigkeitsvergleichsergebnis)

2. Umwelt

3. Bedingungen

--Input ist ein zweidimensionales Array mit dem Standardlistentyp Python

• Die Ausgabe ist der Python-Standardlistentyp numpy.array oder pandas.DataFrame

3-1. Translokationsmatrix

Der Name der zu transponierenden Matrix lautet "in_matrix", und diesmal wird eine 100 × 100-Matrix erzeugt.

Matrix zum Umsetzen

#Matrix zum Verschieben_Erstellen einer Matrix
n = 100
m = 100
in_matrix = [[i for i in range(n)] for j in range(m)]

3-2. Messung der Bearbeitungszeit

Dies geschieht mit dem% timeit des Jupyter Notebook (IPython). Built-in magic commands — %timeit
Die Anzahl der Schleifen beträgt "-n 10000" und die Wiederholung "-r 10".

Messung der Bearbeitungszeit

#Messung der Bearbeitungszeit
%timeit -n 10000 -r 10 turn_matrix(in_matrix)

4. Betrachtete Translokationsmethode

--Übertragung durch Doppelschleife [[turn_matrix1 ()](# 6-1-Übertragung durch Doppelschleife 1), [turn_matrix2 ()](# 6-2-Übertragung durch Doppelschleife 2)] --Übertragung durch eingebaute Funktion zip () [[turn_matrix3 ()](# 6-3-Übertragung durch eingebaute Funktion zip), [turn_matrix4 ()](# 6-4-Übertragung durch eingebaute Funktion zip list Einschlussnotation) )]] --Übertragung durch NumPy [[turn_matrix5 ()](Übertragung durch # 6-5-numpy)] --Übertragung durch Pandas [[turn_matrix6 ()](Übertragung durch # 6-6-Pandas)]

Von den oben genannten basiert die Translokation mit den integrierten Funktionen zip (), NumPy und Pandas auf Folgendem. Zeilen und Spalten des zweidimensionalen Arrays vom Typ Python-Liste austauschen (Translokation) | note.nkmk.me

5. Geschwindigkeitsvergleichsergebnis

Im Vergleich der Translokationsgeschwindigkeiten ist [Übertragung durch NumPy](Übertragung durch # 6-5-numpy) ** überwiegend schneller (1,67 µs) **, gefolgt von [Übertragung durch Pandas](Übertragung durch # 6-6-Pandas). ) (86,3 µs), [Funktion zip () + Listeneinschlussnotation](# 6-4-Übertragung durch integrierte Funktionsziplisteneinschlussnotation) (99,4 µs).

In [Übertragung durch NumPy](Übertragung durch # 6-5-numpy) und [Übertragung durch Pandas](Übertragung durch # 6-6-pandas) beträgt die Konvertierung vom Listentyp in numpy.array jedoch ** 486 µs . , Die Konvertierung in pandas.DataFrame dauert also ** 6,19 ms ** Die Zeit einschließlich der Konvertierung vom Listentyp beträgt [Übertragung durch NumPy](Übertragung durch # 6-5-numpy) ( 487,67 µs ), [Übertragung durch Pandas](Übertragung durch # 6-6-Pandas) Es wurde ( 6,2763 ms **). Wenn es sich bei der angegebenen Matrix um einen Listentyp handelt, beträgt die Gesamtverarbeitungszeit zum Erhalten der transponierten Matrix aus der Listentypmatrix ** [Funktions-Zip () + Listeneinschlussnotation](# 6-4 integrierte Funktions-Zip). (Übertragung durch Listeneinschlussnotation) (99,4 µs) ** wurde als am schnellsten angesehen.

6. Translokationsfunktion

6-1. Inversion durch Doppelschleife 1

Funktionsname: turn_matrix1 () Translokation durch Doppelschleife ohne Referenz erstellt. Übergeben Sie die Anzahl der Zeilen x und die Anzahl der Spalten y des Arguments "Matrix" an die for-Schleife und extrahieren Sie aus dem Argument "Matrix" die Anzahl der Zeilen als Anzahl der Spalten und die Anzahl der Spalten als Anzahl der Zeilen.

Inversion durch Doppelschleife 1

#Matrix zum Verschieben_Erstellen einer Matrix
n = 100
m = 100
in_matrix = [[i for i in range(n)] for j in range(m)]

#Translokationsfunktion drehen_matrix1()
def turn_matrix1(matrix):
    x = len(matrix)
    y = len(matrix[0])    
    turned = []
    for i in range(y):
        tmp = []
        for j in range(x):
            tmp.append(matrix[j][i])
        turned.append(tmp)
    return turned

#Messung der Bearbeitungszeit
%timeit -r 10 -n 10000 turn_matrix1(in_matrix)

** Ausführungsergebnis ** 777 µs ± 43.6 µs per loop (mean ± std. dev. of 10 runs, 10000 loops each)

6-2 Inversion durch Doppelschleife 2

Funktionsname: turn_matrix2 () In [6-1. Translokation 1 durch Doppelschleife](# 6-1-Übertragung 1 durch Doppelschleife) wurden die Anzahl der Zeilen x und die Anzahl der Spalten y des Arguments "Matrix" erfasst, aber das Argument "Matrix" Nehmen Sie von, Zeile für Zeile mit einer for-Schleife heraus, erstellen Sie eine "tmp" -Zeile mit demselben Spaltennummernwert und fügen Sie sie zu "gedreht" hinzu.

Inversion durch Doppelschleife 2

#Matrix zum Verschieben_Erstellen einer Matrix
n = 100
m = 100
in_matrix = [[i for i in range(n)] for j in range(m)]

#Translokationsfunktion drehen_matrix2()
def turn_matrix2(matrix):
    y = len(matrix[0])
    turned = []
    for i in range(y):
        tmp = []
        for j in matrix:
            tmp.append(j[i])
        turned.append(tmp)
    return turned

#Messung der Bearbeitungszeit
%timeit -r 10 -n 10000 turn_matrix2(in_matrix)

** Ausführungsergebnis ** 654 µs ± 83 µs per loop (mean ± std. dev. of 10 runs, 10000 loops each)

6-3. Translokation durch eingebaute Funktion zip ()

Funktionsname: turn_matrix3 ()

Eingebauter Funktionsreißverschluss()Umzug durch

#Matrix zum Verschieben_Erstellen einer Matrix
n = 100
m = 100
in_matrix = [[i for i in range(n)] for j in range(m)]

#Translokationsfunktion drehen_matrix3(matrix)
def turn_matrix3(matrix):
    turned = []
    for i in zip(*matrix):
        turned.append(list(i))
    return turned

#Messung der Bearbeitungszeit
%timeit -r 10 -n 10000 turn_matrix3(in_matrix)

** Ausführungsergebnis ** 105 µs ± 4.22 µs per loop (mean ± std. dev. of 10 runs, 10000 loops each)

6-4. Integrierte Funktion zip () + Translokation nach Listeneinschlussnotation

Funktionsname: turn_matrix4 ()

Eingebauter Funktionsreißverschluss()+Inversion durch Listeneinschlussnotation

#Matrix zum Verschieben_Erstellen einer Matrix
n = 100
m = 100
in_matrix = [[i for i in range(n)] for j in range(m)]

#Translokationsfunktion drehen_matrix4()
def turn_matrix4(matrix):
    return [list(x) for x in zip(*matrix)]

#Messung der Bearbeitungszeit
%timeit -r 10 -n 10000 turn_matrix3(in_matrix)

** Ausführungsergebnis ** 99.4 µs ± 1.36 µs per loop (mean ± std. dev. of 10 runs, 10000 loops each)

• Wenn nicht funktioniert

Listeneinschlussnotation

turned_matrix = [list(x) for x in zip(*in_matrix)] 

Zeilen und Spalten des zweidimensionalen Arrays vom Typ Python-Liste austauschen (Translokation) | note.nkmk.me

6-5. Translokation durch NumPy

Funktionsname: turn_matrix5 ()

Translokation durch NumPy

import numpy as np

#Matrix zum Verschieben_Erstellen einer Matrix
n = 100
m = 100
in_matrix = [[i for i in range(n)] for j in range(m)]

#in_numpy aus der Matrix.Array numpy_in_Erstellen einer Matrix
%timeit numpy_in_matrix = np.array(in_matrix)

#Translokationsfunktion drehen_matrix5()
def turn_matrix5(matrix):
    return matrix.T

#Messung der Bearbeitungszeit
%timeit -r 10 -n 10000 turn_matrix5(numpy_in_matrix)

** Ausführungsergebnis ** Konvertierung von in_matrix nach numpy.array 486 µs ± 10.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Translokation 1.67 µs ± 38.9 ns per loop (mean ± std. dev. of 10 runs, 10000 loops each)

• Wenn nicht funktioniert

Translokation durch NumPy

import numpy as np

turned_matrix = np.array(in_matrix).T

Zeilen und Spalten des zweidimensionalen Arrays vom Typ Python-Liste austauschen (Translokation) | note.nkmk.me

6-6. Umzug durch Pandas

Funktionsname: turn_matrix6 ()

Translokation durch Pandas

import pandas as pd

#Matrix zum Verschieben_Erstellen einer Matrix
n = 100
m = 100
in_matrix = [[i for i in range(n)] for j in range(m)]

#in_Pandas aus der Matrix.DataFrame-Pandas_in_Erstellen einer Matrix
%timeit pandas_in_matrix = pd.DataFrame(in_matrix)

#Translokationsfunktion drehen_matrix6()
def turn_matrix5(matrix):
    return matrix.T

#Messung der Bearbeitungszeit
%timeit -r 10 -n 10000 turn_matrix5(pandas_in_matrix)

** Ausführungsergebnis ** -Konvertierung von in_matrix nach pandas.DataFrame 6.19 ms ± 43.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

· Transfer 86.3 µs ± 4.54 µs per loop (mean ± std. dev. of 10 runs, 10000 loops each)

• Wenn nicht funktioniert

Translokation durch Pandas

import pandas as pd

turned_matrix = pd.DataFrame(in_matrix).T

Zeilen und Spalten des zweidimensionalen Arrays vom Typ Python-Liste austauschen (Translokation) | note.nkmk.me