Pandas Effizienz mit kleinen Daten

Question

Ich bin nur neugierig! Gibt es irgendeine Untergrenze, auf der wir keine Pandas verwenden sollten?

Die Verwendung von Pandas für große Daten ist in Anbetracht der Effizienz und Lesbarkeit gut.

Aber gibt es eine untere Grenze, auf der wir traditionelle Schleifen (Python 3) über Pandas verwenden müssen?

Wann sollte ich Pandas oder Numpy verwenden?

Answer 1

Soweit ich weiß, Pandas verwendet numpy (Vektor-Operationen) unter der Haube ziemlich umfangreich. Numpy ist schneller als Python, weil es Low-Level hat und mehr speicherfreundliches Verhalten als Python (in vielen Fällen). Aber es kommt natürlich darauf an, was du tust. Für numpy-basierte Operationen sollten Pandas die gleiche Leistung haben wie numpy.

Für allgemeine vektorähnliche Operationen (zB Spaltenweise anwenden) ist es immer schneller numpy/pandas zu verwenden.

"für" Schleifen in Python zB. Über Pandas Datenrahmen Zeilen sind langsam.

Wenn Sie nicht vektorisierte Schlüsselsuche in Pandas anwenden müssen. Besser gehen mit so etwas wie Wörterbücher

Verwenden Sie Pandas, wenn Sie Zeitreihen oder Datenrahmen wie Strukturen benötigen. Verwenden Sie numpy, wenn Sie Ihre Daten in Matrizen/Vektoren (Arithmetik) organisieren können.

Bearbeiten: Für sehr kleine Python-Objekt, native Python könnte schneller sein, weil Low-Level-Bibliotheken kleine Overhead einführen!

Numpy Beispiel:

In [21]: a = np.random.rand(10) 

In [22]: a 
Out[22]: 
array([ 0.60555782, 0.14585568, 0.94783553, 0.59123449, 0.07151141, 
     0.6480999 , 0.28743679, 0.19951774, 0.08312469, 0.16396394]) 

In [23]: %timeit a.mean() 
5.16 µs ± 24.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) 

For-Schleife Beispiel:

In [24]: b = a.tolist() 

In [25]: b 
Out[25]: 
[0.6055578242263301, 
0.14585568245745317, 
0.9478355284829876, 
0.5912344944487721, 
0.07151141037216913, 
0.6480999041895205, 
0.2874367896457555, 
0.19951773879879775, 
0.0831246913880146, 
0.16396394311100215] 

In [26]: def mean(x): 
    ...:  s = 0 
    ...:  for i in x: 
    ...:   s += i 
    ...:  return s/len(x) 
    ...: 

In [27]: mean(b) 
Out[27]: 0.37441380071208025 

In [28]: a.mean() 
Out[28]: 0.37441380071208025 

In [29]: %timeit mean(b) 
608 ns ± 2.24 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) 

Ooops, Python for-Schleife ist hier schneller. Es scheint, dass numpy bei jeder Zeit-Iteration einen kleinen Overhead erzeugt (vielleicht von einer Schnittstelle zu c). Also versuchen wir es mit längeren Arrays.

In [34]: a = np.random.rand(int(1e6)) 

In [35]: %timeit a.mean() 
599 µs ± 18.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) 

In [36]: b = a.tolist() 

In [37]: %timeit mean(b) 
31.8 ms ± 102 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) 

Ok, so ist meine Schlussfolgerung, dass es eine Mindestgröße des Objekts, von dem aus auf der Verwendung von niedrigem Niveau Libs wie numpy und Pandas zurück zahlt. Wenn jemand mag, bitte fühlen Sie sich frei, das Experiment mit Pandas zu wiederholen