Warum muss Python Big Data Numpy Array verwenden?

Numpy ist ein Kernmodul des wissenschaftlichen Rechnens mit Python. Es bietet sehr effiziente Array-Objekte sowie Tools zum Arbeiten mit diesen Array-Objekten. Ein Numpy-Array besteht aus vielen Werten, die alle vom gleichen Typ sind.

Die Kernbibliothek von Python bietet Listenlisten. Listen sind einer der häufigsten Python-Datentypen. Sie können in der Größe geändert werden und Elemente unterschiedlichen Typs enthalten, was sehr praktisch ist.

Was ist also der Unterschied zwischen List und Numpy Array? Warum müssen wir Numpy Array verwenden, wenn wir große Datenmengen verarbeiten? Die Antwort ist Leistung.

Numpy-Datenstruktur bietet in folgenden Aspekten eine bessere Leistung:

1. Speichergröße – Numpy-Datenstruktur benötigt weniger Speicher.

2. Leistung – Die unterste Ebene von Numpy ist in der Sprache C implementiert, was schneller als Listen ist.

3. Operationsmethoden – integrierte optimierte algebraische Operationen und andere Methoden.

Im Folgenden werden die Vorteile von Numpy-Arrays gegenüber List bei der Big-Data-Verarbeitung erläutert.

1. Geringere Speichernutzung

Verwenden Sie Numpy-Arrays anstelle von Listen, und Sie können Ihre Speichernutzung um das 20-fache reduzieren.

Für die native Liste von Python werden jedes Mal, wenn ein neues Objekt hinzugefügt wird, 8 Bytes benötigt, um auf das neue Objekt zu verweisen, und das neue Objekt selbst belegt 28 Bytes (am Beispiel von Ganzzahlen). Die Größe der Liste kann also mit der folgenden Formel berechnet werden:

64 + 8 * len(lst) + len(lst) * 28 Bytes

Durch die Verwendung von Numpy kann der Speicherplatzverbrauch erheblich reduziert werden. Beispielsweise erfordert ein Numpy-Integer-Array der Länge n:

96 + len(a) * 8 Bytes

Es ist ersichtlich, dass Sie umso mehr Speicherplatz sparen, je größer das Array ist. Angenommen, Ihr Array verfügt über 1 Milliarde Elemente, dann liegt der Unterschied in der Speichernutzung auf GB-Ebene.

2. Schnellere Geschwindigkeit, integrierte Berechnungsmethode

Führen Sie das folgende Skript aus, das auch zwei Arrays einer bestimmten Dimension generiert und sie zusammenfügt. Sie können den Leistungsunterschied zwischen nativem List und Numpy Array erkennen.

import time
import numpy as np
size_of_vec = 1000
def pure_python_version():
t1 = time.time()
X = range(size_of_vec)
Y = range(size_of_vec)
Z = [X[i] + Y[i] for i in range(len(X)) ]
return time.time() - t1
def numpy_version():
t1 = time.time()
X = np.arange(size_of_vec)
Y = np.arange(size_of_vec)
Z = X + Y
return time.time() - t1
t1 = pure_python_version()
t2 = numpy_version()
print(t1, t2)
print("Numpy is in this example " + str(t1/t2) + " faster!")

Die Ergebnisse sind wie folgt:

0.00048732757568359375 0.0002491474151611328
Numpy is in this example 1.955980861244019 faster!

Wie Sie sehen können, ist Numpy 1,95-mal schneller als native Arrays.

Wenn Sie vorsichtig sind, können Sie auch feststellen, dass das Numpy-Array Additionsoperationen direkt ausführen kann. Native Arrays können dies nicht. Dies ist der Vorteil der Operationsmethode von Numpy.

Wir werden noch mehrere Wiederholungstests durchführen, um zu beweisen, dass dieser Leistungsvorteil dauerhaft ist.

import numpy as np
from timeit import Timer
size_of_vec = 1000
X_list = range(size_of_vec)
Y_list = range(size_of_vec)
X = np.arange(size_of_vec)
Y = np.arange(size_of_vec)
def pure_python_version():
Z = [X_list[i] + Y_list[i] for i in range(len(X_list)) ]
def numpy_version():
Z = X + Y
timer_obj1 = Timer("pure_python_version()",
 "from __main__ import pure_python_version")
timer_obj2 = Timer("numpy_version()",
 "from __main__ import numpy_version")
print(timer_obj1.timeit(10))
print(timer_obj2.timeit(10)) # Runs Faster!
print(timer_obj1.repeat(repeat=3, number=10))
print(timer_obj2.repeat(repeat=3, number=10)) # repeat to prove it!

Die Ergebnisse sind wie folgt:

0.0029753120616078377
0.00014940369874238968
[0.002683573868125677, 0.002754641231149435, 0.002803879790008068]
[6.536301225423813e-05, 2.9387418180704117e-05, 2.9171351343393326e-05]

Es ist ersichtlich, dass die zweite Ausgabezeit immer viel kleiner ist, was beweist, dass dieser Leistungsvorteil anhaltend ist.

Wenn Sie also große Datenmengen recherchieren, beispielsweise Finanzdaten und Aktiendaten, können Sie mit Numpy viel Speicherplatz sparen und eine leistungsfähigere Leistung erzielen.

Referenzen:​​https://www.php.cn/link/5cce25ff8c3ce169488fe6c6f1ad3c97​​

Unser Artikel endet hier. Wenn Ihnen das heutige praktische Python-Tutorial gefällt, folgen Sie uns bitte weiterhin.

Das obige ist der detaillierte Inhalt vonWarum muss Python Big Data Numpy Array verwenden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!