MatLab, Fortran und NumPy

[andreas42]

Hallo Kai, hallo Timo,

Python 2.7.11, Python 3.5.1 und WinPython 3.4.4.1

ah. Mit Python3 werden inkompatible Änderungen eingeführt, die aber eigentlich alle die Sprache konsistenter machen; nur existieren noch unheimlich viele Pakete für Python2, so dass vor ein paar Jahren die Mehrheit der Nutzer noch Python2 verwendet hat. Das ist aber eigentlich gerade am Kippen, es kann also nicht schaden, gleich Python3 zu verwenden. Andererseits sind die Unterschiede so überschaubar, dass man auch recht bald beides im Blick hat.

WinPython scheint mir nicht uninteressant - was ich auf Anhieb unter https://winpython.github.io/ gefunden habe, klingt gut: Lebt in einem Verzeichnis, bringt NumPy und Co. schon mit. Wenn Du es also einfach kurz ausprobieren willst, scheint mir das ein sehr guter Startpunkt zu sein!

garnicht mitbekommen, daß es diese schöne Arbeit-sparenden Array-Funktionen gibt.

Die Array-Funktionen kommen mit NumPy, das im Prinzip native C-Arrays (sowas wie float[1024]) mit Python-Wrappern versieht. Damit ist der Weg sehr kurz, native C- C++ und Fortran-Libraries aus Python heraus anzusprechen. Die Schleifen der Array-Funktionen laufen damit im nativ compilierten Code - also fast genauso schnell wie in C. Das ist unheimlich nützlich. Einen kurzen Überblick findest Du hier: https://docs.scipy.org/doc/numpy-dev/use...start.html

Weitere nützliche Pakete über die Standard-Libary hinaus sind z.B. iPython (eine interaktive Shell mit Highlighting, Syntax-Ergänzung etc. die meinen Taschenrechner und Notizblock ersetzt) und das iPython-Notebook (inzwischen Jupyter), mit dem Du im Browser Code, Ergebnisse, Plots, Kommentare etc. als ausführbare Zellen anzeigen und bedienen kannst.

Für Plots gibt es leider vor allem die etwas vergurkte Matplotlib, mit deren Interface ich nie warmgeworden bin. Allerdings sagt die Webseite: "For simple plotting the pyplot interface provides a MATLAB-like interface, particularly when combined with IPython." - vielleicht liegt es daran...

Nicht zu vergessen ist auch Pandas, was ein statistisches Datenanalyseframework ist. Es hat so manche Eigenheiten, die mich in der Praxis oft gestört haben, wird aber wohl mit der Zeit auch besser. Ich habe es länger nicht verwendet.

Wenn's wirklich auf das letzte Quentchen Performance bei sehr rechenintensiven Anwendungen ankommt, ist Python wahrscheinlich nicht die richtige Wahl.

Performance lässt sich meistens durch Optimierung von wenigen entscheidenden Code-Stellen erreichen.

Wenn reines Python nicht reicht, gibt es den niederschwelligen Weg nach Cython: Das ist eine um statische Typdefinitionen erweiterte Python-Variante, die über C fast unveränderten Python-Code compilieren kann. Wenn man z.B. eine lange Datenschleife hat, bringt es schon enorm viel, den Schleifenzähler als int zu deklarieren und das ganze als Cython-Modul zu übersetzen.

Wenn das noch nicht reicht, kann man auch echten C, C++- oder Fortran-Code ohne viel Interfacing-Arbeit einbauen. Die ideale Arbeitsteilung ist dann, die harten Berechnungen in einer nativen Hochsprache und die Ablaufsteuerung und Ergebnisaufbereitung in Python zu machen.

Es gibt übrigens einen alternativen Python-Interpreter namens PyPy, dem man nachsagt, gelegentlich erheblich schneller zu arbeiten als die Referenzimplementierung CPython.

PyPy verwendet einen Just-In-Time-Compiler, der sich den Code im Betrieb ein paarmal ansieht und dann weiß, welche Variante der Routine wie aufgerufen wird. Damit kann er quasi nach einigen Durchläufen die Typen erraten und optimierten Code erzeugen. Für numerische Berechnugen weiß ich diese Typen aber normalerweise schon vorher, so dass man schon mit NumPy alleine oft schnell genug ist.

Zur Performance noch ein kleines Code-Beispiel: Die im vorigen Thread diskutierte Generierung von 10 Sekunden Sinus, und anschließend die Effektivwertberechnung, in klassischem Python und mit NumPy:

Code:

from math import sin, pi
import numpy as np

def gen_classic(fs=96000, T=10):
    out = []
    for i in range(fs * T):
        out.append(sin(2*pi * 1000 * i / fs))
    return out
        
def gen_lc(fs=96000, T=10):
    return [sin(2*pi * 1000 * i / fs) for i in range(fs * T)]

def gen_np(fs=96000, T=10):
    return np.sin(2*np.pi * 1000 * np.arange(fs*T) / fs)

def eff_classic(a):
    sqsum = 0
    for i in a:
        sqsum += i*i
    return (sqsum / len(a))**.5

def eff_np(a):
    return np.sqrt(1. / len(a) * np.sum(a**2))

Nun hat IPython ein schönes Feature, um einfach die Performance eines Statements zu messen. Die Session sieht so aus:

Code:

Python 2.7.3 (default, Jun 22 2015, 19:33:41)
Type "copyright", "credits" or "license" for more information.

IPython 0.12.1 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]: from perf import *

In [2]: %timeit gen_classic()
1 loops, best of 3: 507 ms per loop

In [3]: %timeit gen_lc()
1 loops, best of 3: 420 ms per loop

In [4]: %timeit gen_np()
10 loops, best of 3: 82.2 ms per loop

In [5]: a1 = gen_classic()

In [6]: a2 = gen_np()

In [7]: %timeit eff_classic(a1)
10 loops, best of 3: 111 ms per loop

In [8]: %timeit eff_np(a2)
100 loops, best of 3: 4.59 ms per loop

Die Variante gen_lc ist immernoch klassisches Python, verwendet aber eine list comprehension, bei der die Schleifen auch wesentlich schneller ausgeführt werden. Die Version gen_classic würde man eigentlich in Python selten so schreiben - das ist quasi aus anderen Sprachen bekannte Elemente in Python übersetzt. Bei der Sample-Erzeugung ist der Unterschied noch moderat - NumPy ist nur etwa 6mal schneller. Bei der Effektivwertberechnung ist schon ein Faktor 24 drin. Je nach Anwendungsfall kann da auch mal 2000 stehen...

Viele Grüße
Andreas