Wie kann man feststellen, ob eine Spalte / Variable in Pandas / NumPy numerisch ist oder nicht?

Gibt es eine bessere Möglichkeit, um festzustellen, ob eine Variable in Pandasund / oder NumPyist numericoder nicht?

Ich habe eine selbstdefinierte dictionarymit dtypesals Schlüssel und numeric/ notals Wert.

In können pandas 0.20.2Sie tun:

import pandas as pd
from pandas.api.types import is_string_dtype
from pandas.api.types import is_numeric_dtype

df = pd.DataFrame({'A': ['a', 'b', 'c'], 'B': [1.0, 2.0, 3.0]})

is_string_dtype(df['A'])
>>>> True

is_numeric_dtype(df['B'])
>>>> True

Sie können np.issubdtypedamit überprüfen, ob der D-Typ ein Sub-D-Typ von ist np.number. Beispiele:

np.issubdtype(arr.dtype, np.number)  # where arr is a numpy array
np.issubdtype(df['X'].dtype, np.number)  # where df['X'] is a pandas Series

Dies funktioniert für numpys dtypes, schlägt jedoch für pandas-spezifische Typen wie pd.Categorical fehl, wie Thomas bemerkte . Wenn Sie kategoriale is_numeric_dtypeFunktionen von Pandas verwenden, ist dies eine bessere Alternative als np.issubdtype.

df = pd.DataFrame({'A': [1, 2, 3], 'B': [1.0, 2.0, 3.0], 
                   'C': [1j, 2j, 3j], 'D': ['a', 'b', 'c']})
df
Out: 
   A    B   C  D
0  1  1.0  1j  a
1  2  2.0  2j  b
2  3  3.0  3j  c

df.dtypes
Out: 
A         int64
B       float64
C    complex128
D        object
dtype: object

np.issubdtype(df['A'].dtype, np.number)
Out: True

np.issubdtype(df['B'].dtype, np.number)
Out: True

np.issubdtype(df['C'].dtype, np.number)
Out: True

np.issubdtype(df['D'].dtype, np.number)
Out: False

Für mehrere Spalten können Sie np.vectorize verwenden:

is_number = np.vectorize(lambda x: np.issubdtype(x, np.number))
is_number(df.dtypes)
Out: array([ True,  True,  True, False], dtype=bool)

Und zur Auswahl hat Pandas jetzt select_dtypes:

df.select_dtypes(include=[np.number])
Out: 
   A    B   C
0  1  1.0  1j
1  2  2.0  2j
2  3  3.0  3j

Basierend auf der Antwort von @ jaime in den Kommentaren müssen Sie nach .dtype.kindder Spalte von Interesse suchen . Zum Beispiel;

>>> import pandas as pd
>>> df = pd.DataFrame({'numeric': [1, 2, 3], 'not_numeric': ['A', 'B', 'C']})
>>> df['numeric'].dtype.kind in 'biufc'
>>> True
>>> df['not_numeric'].dtype.kind in 'biufc'
>>> False

NB Die Bedeutung von biufc: bbool, iint (signiert), uunsigned int, ffloat, ccomplex. Siehe https://docs.scipy.org/doc/numpy/reference/generated/numpy.dtype.kind.html#numpy.dtype.kind

Pandas hat select_dtypeFunktion. Sie können Ihre Spalten auf int64 und float64 einfach wie folgt filtern :

df.select_dtypes(include=['int64','float64'])

Dies ist eine pseudointerne Methode, um nur die numerischen Typdaten zurückzugeben

In [27]: df = DataFrame(dict(A = np.arange(3), 
                             B = np.random.randn(3), 
                             C = ['foo','bar','bah'], 
                             D = Timestamp('20130101')))

In [28]: df
Out[28]: 
   A         B    C                   D
0  0 -0.667672  foo 2013-01-01 00:00:00
1  1  0.811300  bar 2013-01-01 00:00:00
2  2  2.020402  bah 2013-01-01 00:00:00

In [29]: df.dtypes
Out[29]: 
A             int64
B           float64
C            object
D    datetime64[ns]
dtype: object

In [30]: df._get_numeric_data()
Out[30]: 
   A         B
0  0 -0.667672
1  1  0.811300
2  2  2.020402

Wie wäre es, wenn Sie nur den Typ für einen der Werte in der Spalte überprüfen? Wir hatten schon immer so etwas:

isinstance(x, (int, long, float, complex))

Wenn ich versuche, die Datentypen für die Spalten im folgenden Datenrahmen zu überprüfen, erhalte ich sie als 'Objekt' und nicht als numerischen Typ, den ich erwarte:

df = pd.DataFrame(columns=('time', 'test1', 'test2'))
for i in range(20):
    df.loc[i] = [datetime.now() - timedelta(hours=i*1000),i*10,i*100]
df.dtypes

time     datetime64[ns]
test1            object
test2            object
dtype: object

Wenn ich Folgendes mache, scheint es mir ein genaues Ergebnis zu liefern:

isinstance(df['test1'][len(df['test1'])-1], (int, long, float, complex))

kehrt zurück

True

df.info()Um alle anderen Antworten zu ergänzen, kann man auch den Datentyp jeder Spalte ermitteln.

Mit dtypes können Sie überprüfen, ob eine bestimmte Spalte numerische Werte enthält oder nicht

numerical_features = [feature for feature in train_df.columns if train_df[feature].dtypes != 'O']

Hinweis: "O" sollte Kapital sein

Sie können auch versuchen:

df_dtypes = np.array(df.dtypes)
df_numericDtypes= [x.kind in 'bifc' for x in df_dtypes]

Es wird eine Liste von Booleschen Werten zurückgegeben: Truewenn numerisch, Falsewenn nicht.