Python: Ist es besser, viele Variablen zu haben oder ihre Werte in Listen zu speichern?

Question

Ich bin mir bewusst, dass dies wie eine vage Frage scheint, aber ich frage mich, ob es (z. B. in Python) vorzuziehen ist, mehrere Werte in separaten Variablen zu speichern oder in logischen Gruppen (Listen, Arrays ...) zu speichern.

In meinem konkreten Fall soll ich einen Matlab-Code in Python 2.7 übersetzen. Es ist ein physikalisch basiertes Modell, das 8 Eingabevariablen verdaut und zwei große Listen als Ausgabe erstellt. Ich fand, dass das ursprüngliche Modell eine große Menge an Variablen hat, die auf dem Weg berechnet werden (> 100). Als Faustregel gilt: Wenn auf eine Berechnung mehrfach zugegriffen wird, wird sie in einer neuen Variablen gespeichert. Anschauliches Beispiel:

x = 3 
y = 5 
x2 = x**2 
z = x2 + exp(y) 
zz = (y+x)/x2 

x^2 wird verwendet, um zwei mal (für die Berechnung von Z und zz), so wird es als x2 gespeichert. Ist das wirklich schneller als python x ** 2 zweimal berechnen zu lassen? Wäre es auch schneller, wenn ich sie in Listen speichern würde? Wie folgt aus:

x = [3, 5] 
z = x[0]**2 + exp(x[1]) 
zz = sum(x)/x[0]**2 

Die Organisation von Variablen in Listen auf Kosten der Lesbarkeit des Codes kann kommen, aber ich würde gerne, dass, wenn es schneller meinen Code Lauf macht.

Answer 1

Es gibt keinen Leistungsvorteil, den ich sehen kann, es in einer Liste zu halten. Im Gegenteil, sie in einer Liste setzen macht es langsamer:

>>> %%timeit 
...: x = 3 
...: y = 5 
...: x2 = x**2 
...: z = x2 + exp(y) 
...: zz = (y+x)/x2 
...: 
337 ns ± 1.87 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) 

>>> %%timeit 
...: x = [3, 5] 
...: z = x[0]**2 + exp(x[1]) 
...: zz = sum(x)/x[0]**2 
...: 
716 ns ± 4.87 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) 

nun, dass ein Teil ist, weil Sie x**2 zweimal in der Liste Bedingung zu berechnen, aber auch das Problem Festsetzung schneller nicht die Liste Version machen:

Wenn Sie über die Leistung vergleichen, ist ein anderes großes Problem, dass Sie ints definieren und dann in Floats konvertieren. In MATLAB erzeugt x = 5 einen Gleitkommawert, während in Python eine Ganzzahl gebildet wird. Es ist viel schneller alles mit Schwimmern von Anfang an zu tun, die man nur durch ein . oder .0 am Ende der Nummer setzen kann:

>>> %%timeit 
...: x = 3.0 
...: y = 5.0 
...: x2 = x**2.0 
...: z = x2 + exp(y) 
...: zz = (y+x)/x2 
...: 
166 ns ± 1.12 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) 

Wenn Sie als Listen numpy Arrays eher verwenden sind, es noch schlimmer ist, weil Sie mit einer Liste von Schwimmern dann zu tun haben, eine Umwandlung der beiden Zahlen und die Listen, dann wandeln sie zurück, von denen alle langsam beginnen:

>>> %%timeit 
...: x = np.array([3., 5.]) 
...: x0 = x[0]**2. 
...: z = x0 + np.exp(x[1]) 
...: zz = x.sum()/x0 
...: 
3.22 µs ± 8.96 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) 

Als allgemeine Regel zu vermeiden wenn möglich, Typkonvertierungen durchzuführen und Indexierung zu vermeiden, wenn dies der Lesbarkeit nicht hilft. Wenn Sie mehrere Werte haben, ist die Konvertierung in numpy nützlich. Aber für nur zwei oder drei wird es Geschwindigkeit und Lesbarkeit verletzen.