Scipy interpolieren gibt eine ‚dimensionslose‘ Array

Question

Ich verstehe, dass interp1d erwartet ein Array von Werten zu interpolieren, aber das Verhalten beim Passieren es ein Schwimmer seltsam genug ist, um zu fragen, was los ist und was genau zurückgegeben wird

import numpy as np 
from scipy.interpolate import interp1d 

x = np.array([1,2,3,4]) 
y = np.array([5,7,9,15]) 
f = interp1d(x,y, kind='cubic') 
a = f(2.5) 

print(repr(a)) 
print("type is {}".format(type(a))) 
print("shape is {}".format(a.shape)) 
print("ndim is {}".format(a.ndim)) 
print(a) 

Ausgang:

array(7.749999999999992) 
type is <class 'numpy.ndarray'> 
shape is() 
ndim is 0 
7.749999999999992 

EDIT: um zu klären, würde ich nicht erwarten numpy noch viel weniger eine scipy Funktion Rückkehr man eine dimensionslose, unförmig Array haben.

print("Numpy version is {}".format(np.__version__)) 
print("Scipy version is {}".format(scipy.__version__)) 

Numpy version is 1.10.4 
Scipy version is 0.17.0 

Answer 1

Der interp1d gibt einen Wert, der die Eingabe in Form passt - nach in np.array() Einwickeln bei Bedarf:

In [324]: f([1,2,3]) 
Out[324]: array([ 5., 7., 9.]) 

In [325]: f([2.5]) 
Out[325]: array([ 7.75]) 

In [326]: f(2.5) 
Out[326]: array(7.75) 

In [327]: f(np.array(2.5)) 
Out[327]: array(7.75) 

Viele numpy Operationen Skalare tun zurückkehren statt 0T Arrays.

In [330]: np.arange(3).sum() 
Out[330]: 3 

obwohl tatsächlich gibt es ein numpy Objekt

In [341]: type(np.arange(3).sum()) 
Out[341]: numpy.int32 

, die eine () und NDIM 0 Form hat.

Während interp1d ein Array zurückgibt.

In [344]: type(f(2.5)) 
Out[344]: numpy.ndarray 

Sie können den Wert mit [()] Indizierung extrahieren

In [345]: f(2.5)[()] 
Out[345]: 7.75 

In [346]: type(f(2.5)[()]) 
Out[346]: numpy.float64 

Dies kann nur ein Versehen in der scipy Code sein. Wie oft wollen Menschen nur an einem Punkt interpolieren? Interpoliert nicht über ein reguläres Raster von Punkten häufiger?

==================

Die Dokumentation für f.__call__ ist ganz explizit über ein Array zurück.

Evaluate the interpolant 

Parameters 
---------- 
x : array_like 
    Points to evaluate the interpolant at. 

Returns 
------- 
y : array_like 
    Interpolated values. Shape is determined by replacing 
    the interpolation axis in the original array with the shape of x. 

===============

Die andere Seite auf die Frage, warum nicht numpy sogar eine 0T Array. Die verknüpfte Antwort ist wahrscheinlich ausreichend. Aber oft wird die Frage von Leuten gestellt, die an MATLAB gewöhnt sind. In MATLAB ist fast alles 2D. Es gibt keine (wahren) Skalare. Jetzt hat MATLAB Strukturen und Zellen und Matrizen mit mehr als 2 Dimensionen. Aber ich erinnere mich an eine Zeit (in den 1990er Jahren), als es diese nicht hatte. Alles, buchstäblich, war eine 2d-Matrix.

Der np.matrix approximiert diesen MATLAB-Fall, indem er seine Arrays auf 2d fixiert. Aber es hat eine _collapse Methode, die einen 'Skalar' zurückgeben kann.