Ich bin daran interessiert zu wissen, wie man einen Pandas-Datenrahmen in ein NumPy-Array konvertiert.

Datenrahmen:

import numpy as np
import pandas as pd

index = [1, 2, 3, 4, 5, 6, 7]
a = [np.nan, np.nan, np.nan, 0.1, 0.1, 0.1, 0.1]
b = [0.2, np.nan, 0.2, 0.2, 0.2, np.nan, np.nan]
c = [np.nan, 0.5, 0.5, np.nan, 0.5, 0.5, np.nan]
df = pd.DataFrame({'A': a, 'B': b, 'C': c}, index=index)
df = df.rename_axis('ID')

gibt

label   A    B    C
ID                                 
1   NaN  0.2  NaN
2   NaN  NaN  0.5
3   NaN  0.2  0.5
4   0.1  0.2  NaN
5   0.1  0.2  0.5
6   0.1  NaN  0.5
7   0.1  NaN  NaN

Ich möchte dies wie folgt in ein NumPy-Array konvertieren:

array([[ nan,  0.2,  nan],
       [ nan,  nan,  0.5],
       [ nan,  0.2,  0.5],
       [ 0.1,  0.2,  nan],
       [ 0.1,  0.2,  0.5],
       [ 0.1,  nan,  0.5],
       [ 0.1,  nan,  nan]])

Wie kann ich das machen?

Ist es als Bonus möglich, die d-Typen so zu erhalten?

array([[ 1, nan,  0.2,  nan],
       [ 2, nan,  nan,  0.5],
       [ 3, nan,  0.2,  0.5],
       [ 4, 0.1,  0.2,  nan],
       [ 5, 0.1,  0.2,  0.5],
       [ 6, 0.1,  nan,  0.5],
       [ 7, 0.1,  nan,  nan]],
     dtype=[('ID', '<i4'), ('A', '<f8'), ('B', '<f8'), ('B', '<f8')])

o.ä?

Verwenden Sie diesen Code, um einen Pandas-Datenrahmen (df) in einen numpy ndarray zu konvertieren:

df.values

array([[nan, 0.2, nan],
       [nan, nan, 0.5],
       [nan, 0.2, 0.5],
       [0.1, 0.2, nan],
       [0.1, 0.2, 0.5],
       [0.1, nan, 0.5],
       [0.1, nan, nan]])

Verwerfen Sie Ihre Verwendung von valuesund as_matrix()!

In pandas v0.24.0 wurden zwei neue Methoden zum Abrufen von NumPy-Arrays aus Pandas-Objekten eingeführt:

1. to_numpy(), die auf und Objekte definiert Indexist , undSeries,DataFrame
2. array, die nur für Indexund SeriesObjekte definiert ist .

Wenn Sie die v0.24-Dokumente für besuchen .values, wird eine große rote Warnung angezeigt , die besagt:

Warnung: Wir empfehlen DataFrame.to_numpy()stattdessen die Verwendung .

Weitere Informationen finden Sie in diesem Abschnitt der Versionshinweise zu Version 0.24.0 und in dieser Antwort .

Auf dem Weg zu einer besseren Konsistenz: to_numpy()

Im Sinne einer besseren Konsistenz in der gesamten API wurde eine neue Methode to_numpyeingeführt, um das zugrunde liegende NumPy-Array aus DataFrames zu extrahieren.

# Setup.
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}, index=['a', 'b', 'c'])

df.to_numpy()
array([[1, 4],
       [2, 5],
       [3, 6]])

Wie oben erwähnt, ist diese Methode auch für Indexund SeriesObjekte definiert (siehe hier ).

df.index.to_numpy()
# array(['a', 'b', 'c'], dtype=object)

df['A'].to_numpy()
#  array([1, 2, 3])

Standardmäßig wird eine Ansicht zurückgegeben, sodass alle vorgenommenen Änderungen das Original beeinflussen.

v = df.to_numpy()
v[0, 0] = -1

df
   A  B
a -1  4
b  2  5
c  3  6

Wenn Sie stattdessen eine Kopie benötigen, verwenden Sie to_numpy(copy=True).

pandas> = 1.0 Update für ExtensionTypes

Wenn Sie pandas 1.x verwenden, werden Sie wahrscheinlich viel mehr mit Erweiterungstypen zu tun haben. Sie müssen etwas vorsichtiger sein, dass diese Erweiterungstypen korrekt konvertiert werden.

a = pd.array([1, 2, None], dtype="Int64")                                  
a                                                                          

<IntegerArray>
[1, 2, <NA>]
Length: 3, dtype: Int64 

# Wrong
a.to_numpy()                                                               
# array([1, 2, <NA>], dtype=object)  # yuck, objects

# Right
a.to_numpy(dtype='float', na_value=np.nan)                                 
# array([ 1.,  2., nan])

Dies wird in den Dokumenten erwähnt .

Wenn Sie die dtypes...

Wie in einer anderen Antwort gezeigt, DataFrame.to_recordsist dies ein guter Weg, dies zu tun.

df.to_records()
# rec.array([('a', -1, 4), ('b',  2, 5), ('c',  3, 6)],
#           dtype=[('index', 'O'), ('A', '<i8'), ('B', '<i8')])

Dies ist to_numpyleider nicht möglich. Alternativ können Sie jedoch Folgendes verwenden np.rec.fromrecords:

v = df.reset_index()
np.rec.fromrecords(v, names=v.columns.tolist())
# rec.array([('a', -1, 4), ('b',  2, 5), ('c',  3, 6)],
#          dtype=[('index', '<U1'), ('A', '<i8'), ('B', '<i8')])

In Bezug auf die Leistung ist es fast das gleiche (tatsächlich ist die Verwendung rec.fromrecordsetwas schneller).

df2 = pd.concat([df] * 10000)

%timeit df2.to_records()
%%timeit
v = df2.reset_index()
np.rec.fromrecords(v, names=v.columns.tolist())

11.1 ms ± 557 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
9.67 ms ± 126 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Begründung für das Hinzufügen einer neuen Methode

to_numpy()(zusätzlich zu array) wurde als Ergebnis von Diskussionen unter zwei GitHub-Ausgaben GH19954 und GH23623 hinzugefügt .

In den Dokumenten wird insbesondere die Begründung erwähnt:

[...] .valuesdabei war unklar, ob der zurückgegebene Wert das tatsächliche Array, eine Transformation davon oder eines der benutzerdefinierten Pandas-Arrays (wie Categorical) sein würde. Zum Beispiel mit PeriodIndex, .values erzeugt eine neue ndarrayPerioden Objekte jedes Mal. [...]

to_numpyZiel ist es, die Konsistenz der API zu verbessern, was ein wichtiger Schritt in die richtige Richtung ist. .valueswird in der aktuellen Version nicht veraltet sein, aber ich gehe davon aus, dass dies irgendwann in der Zukunft passieren wird. Daher möchte ich die Benutzer dringend bitten, so bald wie möglich auf die neuere API zu migrieren.

Kritik anderer Lösungen

DataFrame.values hat inkonsistentes Verhalten, wie bereits erwähnt.

DataFrame.get_values()ist einfach ein Wrapper herum DataFrame.values, also gilt alles, was oben gesagt wurde.

DataFrame.as_matrix()ist jetzt veraltet, NICHT verwenden!

Hinweis : Die .as_matrix()in dieser Antwort verwendete Methode ist veraltet. Pandas 0.23.4 warnt:

Die Methode .as_matrixwird in einer zukünftigen Version entfernt. Verwenden Sie stattdessen .values.

Pandas hat etwas eingebaut ...

numpy_matrix = df.as_matrix()

gibt

array([[nan, 0.2, nan],
       [nan, nan, 0.5],
       [nan, 0.2, 0.5],
       [0.1, 0.2, nan],
       [0.1, 0.2, 0.5],
       [0.1, nan, 0.5],
       [0.1, nan, nan]])

Ich würde nur die Funktionen DataFrame.reset_index () und DataFrame.values ​​verketten , um die Numpy-Darstellung des Datenrahmens einschließlich des Index zu erhalten:

In [8]: df
Out[8]: 
          A         B         C
0 -0.982726  0.150726  0.691625
1  0.617297 -0.471879  0.505547
2  0.417123 -1.356803 -1.013499
3 -0.166363 -0.957758  1.178659
4 -0.164103  0.074516 -0.674325
5 -0.340169 -0.293698  1.231791
6 -1.062825  0.556273  1.508058
7  0.959610  0.247539  0.091333

[8 rows x 3 columns]

In [9]: df.reset_index().values
Out[9]:
array([[ 0.        , -0.98272574,  0.150726  ,  0.69162512],
       [ 1.        ,  0.61729734, -0.47187926,  0.50554728],
       [ 2.        ,  0.4171228 , -1.35680324, -1.01349922],
       [ 3.        , -0.16636303, -0.95775849,  1.17865945],
       [ 4.        , -0.16410334,  0.0745164 , -0.67432474],
       [ 5.        , -0.34016865, -0.29369841,  1.23179064],
       [ 6.        , -1.06282542,  0.55627285,  1.50805754],
       [ 7.        ,  0.95961001,  0.24753911,  0.09133339]])

Um die dtypes zu erhalten, müssten wir dieses ndarray mit view in ein strukturiertes Array umwandeln :

In [10]: df.reset_index().values.ravel().view(dtype=[('index', int), ('A', float), ('B', float), ('C', float)])
Out[10]:
array([( 0, -0.98272574,  0.150726  ,  0.69162512),
       ( 1,  0.61729734, -0.47187926,  0.50554728),
       ( 2,  0.4171228 , -1.35680324, -1.01349922),
       ( 3, -0.16636303, -0.95775849,  1.17865945),
       ( 4, -0.16410334,  0.0745164 , -0.67432474),
       ( 5, -0.34016865, -0.29369841,  1.23179064),
       ( 6, -1.06282542,  0.55627285,  1.50805754),
       ( 7,  0.95961001,  0.24753911,  0.09133339),
       dtype=[('index', '<i8'), ('A', '<f8'), ('B', '<f8'), ('C', '<f8')])

Sie können die to_recordsMethode verwenden, müssen aber ein wenig mit den dtypes herumspielen, wenn sie von Anfang an nicht das sind, was Sie wollen. In meinem Fall ist der Indextyp nach dem Kopieren Ihres DF aus einer Zeichenfolge eine Zeichenfolge (dargestellt durch einen d- objectTyp in Pandas):

In [102]: df
Out[102]: 
label    A    B    C
ID                  
1      NaN  0.2  NaN
2      NaN  NaN  0.5
3      NaN  0.2  0.5
4      0.1  0.2  NaN
5      0.1  0.2  0.5
6      0.1  NaN  0.5
7      0.1  NaN  NaN

In [103]: df.index.dtype
Out[103]: dtype('object')
In [104]: df.to_records()
Out[104]: 
rec.array([(1, nan, 0.2, nan), (2, nan, nan, 0.5), (3, nan, 0.2, 0.5),
       (4, 0.1, 0.2, nan), (5, 0.1, 0.2, 0.5), (6, 0.1, nan, 0.5),
       (7, 0.1, nan, nan)], 
      dtype=[('index', '|O8'), ('A', '<f8'), ('B', '<f8'), ('C', '<f8')])
In [106]: df.to_records().dtype
Out[106]: dtype([('index', '|O8'), ('A', '<f8'), ('B', '<f8'), ('C', '<f8')])

Das Konvertieren des Recarray-D-Typs funktioniert bei mir nicht, aber in Pandas kann man dies bereits tun:

In [109]: df.index = df.index.astype('i8')
In [111]: df.to_records().view([('ID', '<i8'), ('A', '<f8'), ('B', '<f8'), ('C', '<f8')])
Out[111]:
rec.array([(1, nan, 0.2, nan), (2, nan, nan, 0.5), (3, nan, 0.2, 0.5),
       (4, 0.1, 0.2, nan), (5, 0.1, 0.2, 0.5), (6, 0.1, nan, 0.5),
       (7, 0.1, nan, nan)], 
      dtype=[('ID', '<i8'), ('A', '<f8'), ('B', '<f8'), ('C', '<f8')])

Beachten Sie, dass Pandas den Namen des Index IDim exportierten Datensatzarray nicht richtig (auf ) setzt (ein Fehler?), Sodass wir von der Typkonvertierung profitieren, um dies ebenfalls zu korrigieren.

Im Moment hat Pandas nur 8-Byte-Ganzzahlen i8und Floats f8(siehe diese Ausgabe ).

Es scheint, als würde df.to_records()es für Sie funktionieren. Die genaue Funktion, nach der Sie suchen, wurde angefordert und to_recordsals Alternative angegeben.

Ich habe dies lokal anhand Ihres Beispiels ausprobiert, und dieser Aufruf liefert etwas, das der gesuchten Ausgabe sehr ähnlich ist:

rec.array([(1, nan, 0.2, nan), (2, nan, nan, 0.5), (3, nan, 0.2, 0.5),
       (4, 0.1, 0.2, nan), (5, 0.1, 0.2, 0.5), (6, 0.1, nan, 0.5),
       (7, 0.1, nan, nan)],
      dtype=[(u'ID', '<i8'), (u'A', '<f8'), (u'B', '<f8'), (u'C', '<f8')])

Beachten Sie, dass dies recarrayeher ein als ein ist array. Sie können das Ergebnis in ein reguläres numpy-Array verschieben, indem Sie dessen Konstruktor als aufrufen np.array(df.to_records()).

Versuche dies:

a = numpy.asarray(df)

Hier ist mein Ansatz zum Erstellen eines Strukturarrays aus einem Pandas-DataFrame.

Erstellen Sie den Datenrahmen

import pandas as pd
import numpy as np
import six

NaN = float('nan')
ID = [1, 2, 3, 4, 5, 6, 7]
A = [NaN, NaN, NaN, 0.1, 0.1, 0.1, 0.1]
B = [0.2, NaN, 0.2, 0.2, 0.2, NaN, NaN]
C = [NaN, 0.5, 0.5, NaN, 0.5, 0.5, NaN]
columns = {'A':A, 'B':B, 'C':C}
df = pd.DataFrame(columns, index=ID)
df.index.name = 'ID'
print(df)

      A    B    C
ID               
1   NaN  0.2  NaN
2   NaN  NaN  0.5
3   NaN  0.2  0.5
4   0.1  0.2  NaN
5   0.1  0.2  0.5
6   0.1  NaN  0.5
7   0.1  NaN  NaN

Definieren Sie eine Funktion zum Erstellen eines Numpy-Struktur-Arrays (kein Datensatz-Array) aus einem Pandas-DataFrame.

def df_to_sarray(df):
    """
    Convert a pandas DataFrame object to a numpy structured array.
    This is functionally equivalent to but more efficient than
    np.array(df.to_array())

    :param df: the data frame to convert
    :return: a numpy structured array representation of df
    """

    v = df.values
    cols = df.columns

    if six.PY2:  # python 2 needs .encode() but 3 does not
        types = [(cols[i].encode(), df[k].dtype.type) for (i, k) in enumerate(cols)]
    else:
        types = [(cols[i], df[k].dtype.type) for (i, k) in enumerate(cols)]
    dtype = np.dtype(types)
    z = np.zeros(v.shape[0], dtype)
    for (i, k) in enumerate(z.dtype.names):
        z[k] = v[:, i]
    return z

Verwenden Sie reset_indexdiese Option , um einen neuen Datenrahmen zu erstellen, der den Index als Teil seiner Daten enthält. Konvertieren Sie diesen Datenrahmen in ein Strukturarray.

sa = df_to_sarray(df.reset_index())
sa

array([(1L, nan, 0.2, nan), (2L, nan, nan, 0.5), (3L, nan, 0.2, 0.5),
       (4L, 0.1, 0.2, nan), (5L, 0.1, 0.2, 0.5), (6L, 0.1, nan, 0.5),
       (7L, 0.1, nan, nan)], 
      dtype=[('ID', '<i8'), ('A', '<f8'), ('B', '<f8'), ('C', '<f8')])

BEARBEITEN: df_to_sarray wurde aktualisiert, um Fehler beim Aufrufen von .encode () mit Python 3 zu vermeiden. Vielen Dank an Joseph Garvin und halcyon für ihren Kommentar und ihre Lösung.

Zwei Möglichkeiten, den Datenrahmen in seine Numpy-Array-Darstellung zu konvertieren.

• mah_np_array = df.as_matrix(columns=None)

• mah_np_array = df.values

Doc: https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.as_matrix.html

Ein einfacher Weg für Beispiel DataFrame:

df

         gbm       nnet        reg
0  12.097439  12.047437  12.100953
1  12.109811  12.070209  12.095288
2  11.720734  11.622139  11.740523
3  11.824557  11.926414  11.926527
4  11.800868  11.727730  11.729737
5  12.490984  12.502440  12.530894

VERWENDEN:

np.array(df.to_records().view(type=np.matrix))

ERHALTEN:

array([[(0, 12.097439  , 12.047437, 12.10095324),
        (1, 12.10981081, 12.070209, 12.09528824),
        (2, 11.72073428, 11.622139, 11.74052253),
        (3, 11.82455653, 11.926414, 11.92652727),
        (4, 11.80086775, 11.72773 , 11.72973699),
        (5, 12.49098389, 12.50244 , 12.53089367)]],
dtype=(numpy.record, [('index', '<i8'), ('gbm', '<f8'), ('nnet', '<f4'),
       ('reg', '<f8')]))

Hatte gerade ein ähnliches Problem beim Exportieren vom Datenrahmen in die Arcgis-Tabelle und bin auf eine Lösung von usgs gestoßen ( https://my.usgs.gov/confluence/display/cdi/pandas.DataFrame+to+ArcGIS+Table ). Kurz gesagt, Ihr Problem hat eine ähnliche Lösung:

df

      A    B    C
ID               
1   NaN  0.2  NaN
2   NaN  NaN  0.5
3   NaN  0.2  0.5
4   0.1  0.2  NaN
5   0.1  0.2  0.5
6   0.1  NaN  0.5
7   0.1  NaN  NaN

np_data = np.array(np.rec.fromrecords(df.values))
np_names = df.dtypes.index.tolist()
np_data.dtype.names = tuple([name.encode('UTF8') for name in np_names])

np_data

array([( nan,  0.2,  nan), ( nan,  nan,  0.5), ( nan,  0.2,  0.5),
       ( 0.1,  0.2,  nan), ( 0.1,  0.2,  0.5), ( 0.1,  nan,  0.5),
       ( 0.1,  nan,  nan)], 
      dtype=(numpy.record, [('A', '<f8'), ('B', '<f8'), ('C', '<f8')]))

Ich habe die obigen Antworten durchgesehen. Die Methode " as_matrix () " funktioniert, ist aber jetzt veraltet. Für mich funktionierte " .to_numpy () ".

Dies gibt ein mehrdimensionales Array zurück. Ich bevorzuge diese Methode, wenn Sie Daten aus Excel-Tabellen lesen und auf Daten aus einem beliebigen Index zugreifen müssen. Hoffe das hilft :)

Nach Meteores Antwort fand ich den Code

df.index = df.index.astype('i8')

funktioniert bei mir nicht Deshalb habe ich meinen Code hier eingefügt, damit andere sich mit diesem Problem befassen können.

city_cluster_df = pd.read_csv(text_filepath, encoding='utf-8')
# the field 'city_en' is a string, when converted to Numpy array, it will be an object
city_cluster_arr = city_cluster_df[['city_en','lat','lon','cluster','cluster_filtered']].to_records()
descr=city_cluster_arr.dtype.descr
# change the field 'city_en' to string type (the index for 'city_en' here is 1 because before the field is the row index of dataframe)
descr[1]=(descr[1][0], "S20")
newArr=city_cluster_arr.astype(np.dtype(descr))

Eine einfache Möglichkeit, Datenrahmen in Numpy-Arrays zu konvertieren:

import pandas as pd
df = pd.DataFrame({"A": [1, 2], "B": [3, 4]})
df_to_array = df.to_numpy()
array([[1, 3],
   [2, 4]])

Die Verwendung von to_numpy wird empfohlen, um die Konsistenz zu gewährleisten.

Referenz: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_numpy.html

Versuche dies:

np.array(df) 

array([['ID', nan, nan, nan],
   ['1', nan, 0.2, nan],
   ['2', nan, nan, 0.5],
   ['3', nan, 0.2, 0.5],
   ['4', 0.1, 0.2, nan],
   ['5', 0.1, 0.2, 0.5],
   ['6', 0.1, nan, 0.5],
   ['7', 0.1, nan, nan]], dtype=object)

Weitere Informationen unter: [ https://docs.scipy.org/doc/numpy/reference/generated/numpy.array.html] Gültig für numpy 1.16.5 und pandas 0.25.2.