Tôi muốn biết làm thế nào để chuyển đổi một khung dữ liệu gấu trúc thành một mảng NumPy.

khung dữ liệu:

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')

cho

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

Tôi muốn chuyển đổi nó thành một mảng NumPy, như vậy:

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]])

Tôi có thể làm cái này như thế nào?

Như một phần thưởng, có thể bảo tồn các dtypes, như thế này?

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')])

hoặc tương tự?

Để chuyển đổi một cơ sở dữ liệu gấu trúc (df) thành một ndarray numpy, sử dụng mã này:

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]])

Không dùng nữa valuesvà as_matrix()!

pandas v0.24.0 đã giới thiệu hai phương thức mới để lấy mảng NumPy từ các đối tượng gấu trúc:

1. to_numpy(), được định nghĩa trên Index, Series,và DataFramecác đối tượng, và
2. array, được định nghĩa trên Indexvà Serieschỉ các đối tượng.

Nếu bạn truy cập tài liệu v0.24 cho .values, bạn sẽ thấy một cảnh báo lớn màu đỏ có nội dung:

Cảnh báo: Chúng tôi khuyên bạn nên sử dụng DataFrame.to_numpy()thay thế.

Xem phần này của ghi chú phát hành v0.24.0 và câu trả lời này để biết thêm thông tin.

Hướng tới tính nhất quán tốt hơn: to_numpy()

Với tinh thần thống nhất tốt hơn trong suốt API, một phương pháp mới to_numpyđã được giới thiệu để trích xuất mảng NumPy cơ bản từ DataFrames.

# 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]])

Như đã đề cập ở trên, phương thức này cũng được định nghĩa Indexvà Seriescác đối tượng (xem tại đây ).

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

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

Theo mặc định, chế độ xem được trả về, vì vậy mọi sửa đổi được thực hiện sẽ ảnh hưởng đến bản gốc.

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

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

Nếu bạn cần một bản sao thay thế, sử dụng to_numpy(copy=True).

gấu trúc> = 1.0 cập nhật cho ExtensionTypes

Nếu bạn đang sử dụng gấu trúc 1.x, nhiều khả năng bạn sẽ phải đối phó với các loại tiện ích mở rộng hơn rất nhiều. Bạn sẽ phải cẩn thận hơn một chút rằng các loại tiện ích mở rộng này được chuyển đổi chính xác.

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])

Điều này được gọi ra trong các tài liệu .

Nếu bạn cần dtypes...

Như thể hiện trong một câu trả lời khác, DataFrame.to_recordslà một cách tốt để làm điều này.

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

Điều này không thể được thực hiện với to_numpy, không may. Tuy nhiên, để thay thế, bạn có thể sử dụng 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')])

Hiệu suất khôn ngoan, nó gần giống nhau (thực ra, sử dụng rec.fromrecordsnhanh hơn một chút).

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)

Cơ sở lý luận để thêm một phương pháp mới

to_numpy()(ngoài array) đã được thêm vào do kết quả của các cuộc thảo luận theo hai vấn đề GitHub GH19954 và GH23623 .

Cụ thể, các tài liệu đề cập đến lý do:

[...] với .valuesnó không rõ liệu giá trị được trả về sẽ là mảng thực tế, một số biến đổi của nó hoặc một trong các mảng tùy chỉnh gấu trúc (như Categorical). Ví dụ, với PeriodIndex, .values tạo ra một ndarrayđối tượng thời gian mới mỗi lần. [...]

to_numpynhằm cải thiện tính nhất quán của API, đây là một bước quan trọng theo đúng hướng. .valuessẽ không bị phản đối trong phiên bản hiện tại, nhưng tôi hy vọng điều này có thể xảy ra vào một thời điểm nào đó trong tương lai, vì vậy tôi sẽ khuyến khích người dùng chuyển sang API mới hơn, ngay khi bạn có thể.

Phê bình các giải pháp khác

DataFrame.values có hành vi không nhất quán, như đã lưu ý.

DataFrame.get_values()chỉ đơn giản là một trình bao bọc xung quanh DataFrame.values, vì vậy mọi thứ nói ở trên đều áp dụng.

DataFrame.as_matrix()bây giờ không được dùng nữa, KHÔNG sử dụng!

Lưu ý : .as_matrix()Phương pháp được sử dụng trong câu trả lời này không được dùng nữa. Gấu trúc 0.23.4 cảnh báo:

Phương pháp .as_matrixsẽ được gỡ bỏ trong một phiên bản trong tương lai. Sử dụng .values ​​thay thế.

Gấu trúc có một cái gì đó được xây dựng trong ...

numpy_matrix = df.as_matrix()

cho

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]])

Tôi sẽ chỉ xâu chuỗi các hàm DataFrame.reset_index () và DataFrame.values để có được biểu diễn Numpy của dataframe, bao gồm cả chỉ mục:

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]])

Để có được các kiểu chữ, chúng ta cần chuyển đổi ndarray này thành một mảng có cấu trúc bằng cách sử dụng view :

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')])

Bạn có thể sử dụng to_recordsphương pháp này, nhưng phải chơi xung quanh một chút với các dtypes nếu chúng không phải là những gì bạn muốn từ việc di chuyển. Trong trường hợp của tôi, khi đã sao chép DF của bạn từ một chuỗi, loại chỉ mục là chuỗi (được đại diện bởi một objectdtype trong gấu trúc):

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')])

Chuyển đổi dtype recarray không hiệu quả với tôi, nhưng người ta có thể làm điều này trong Pandas rồi:

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')])

Lưu ý rằng Pandas không đặt đúng tên của chỉ mục (thành ID) trong mảng bản ghi đã xuất (lỗi?), Vì vậy chúng tôi thu lợi từ chuyển đổi loại cũng chính xác cho điều đó.

Hiện tại Pandas chỉ có số nguyên 8 byte i8và nổi, f8(xem vấn đề này ).

Có vẻ như df.to_records()sẽ làm việc cho bạn. Tính năng chính xác mà bạn đang tìm kiếm được yêu cầu và được to_recordschỉ ra như là một thay thế.

Tôi đã thử điều này tại địa phương bằng ví dụ của bạn và cuộc gọi đó mang lại một cái gì đó rất giống với đầu ra mà bạn đang tìm kiếm:

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')])

Lưu ý rằng đây là một recarraychứ không phải là một array. Bạn có thể di chuyển kết quả vào mảng numpy thông thường bằng cách gọi hàm tạo của nó là np.array(df.to_records()).

Thử cái này:

a = numpy.asarray(df)

Đây là cách tiếp cận của tôi để tạo một mảng cấu trúc từ DataFrame của gấu trúc.

Tạo khung dữ liệu

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

Xác định hàm để tạo một mảng cấu trúc gọn gàng (không phải là mảng bản ghi) từ DataFrame của gấu trúc.

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

Sử dụng reset_indexđể tạo khung dữ liệu mới bao gồm chỉ mục như một phần của dữ liệu. Chuyển đổi khung dữ liệu đó thành một mảng cấu trúc.

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')])

EDIT: Đã cập nhật df_to_sarray để tránh lỗi gọi .encode () bằng python 3. Cảm ơn Joseph Garvin và halcyon về nhận xét và giải pháp của họ.

Hai cách để chuyển đổi khung dữ liệu thành biểu diễn Numpy-mảng.

• mah_np_array = df.as_matrix(columns=None)

• mah_np_array = df.values

Tài liệu: https://pandas.pydata.org/pandas-docs/urdy/generated/pandas.DataFrame.as_matrix.html

Một cách đơn giản hơn cho DataFrame ví dụ:

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

SỬ DỤNG:

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

ĐƯỢC:

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')]))

Chỉ gặp vấn đề tương tự khi xuất từ ​​dataframe sang bảng arcgis và tình cờ tìm thấy giải pháp từ usss ( https://my.usgs.gov/confluence/display/cdi/pandas.DataFrame+to+ArcGIS+Table ). Trong ngắn hạn, vấn đề của bạn có một giải pháp tương tự:

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')]))

Tôi đã đi qua các câu trả lời ở trên. Phương thức " as_matrix () " hoạt động nhưng hiện đã lỗi thời. Đối với tôi, những gì đã làm việc là " .to_numpy () ".

Điều này trả về một mảng nhiều chiều. Tôi sẽ thích sử dụng phương pháp này nếu bạn đang đọc dữ liệu từ bảng excel và bạn cần truy cập dữ liệu từ bất kỳ chỉ mục nào. Hi vọng điêu nay co ich :)

Hơn nữa với câu trả lời của meteore, tôi tìm thấy mã

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

không làm việc cho tôi. Vì vậy, tôi đặt mã của mình ở đây để thuận tiện cho những người khác bị mắc kẹt với vấn đề này.

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))

Một cách đơn giản để chuyển đổi khung dữ liệu thành mảng numpy:

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

Việc sử dụng to_numpy được khuyến khích để duy trì tính nhất quán.

Tham khảo: https://pandas.pydata.org/pandas-docs/urdy/reference/api/pandas.DataFrame.to_numpy.html

Thử cái này:

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)

Một số thông tin khác tại: [ https://docs.scipy.org/doc/numpy/reference/generated/numpy.array.html] Hợp lệ cho numpy 1.16.5 và gấu trúc 0.25.2.