465

मुझे यह जानने में दिलचस्पी है कि कैसे एक पांडा डेटाफ्रेम को एक न्यूपी सरणी में परिवर्तित किया जाए।

डेटा ढांचा:

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

देता है

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

मैं इसे एक NumPy सरणी में बदलना चाहता हूं, जैसे:

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

मैं यह कैसे कर सकता हूँ?

एक बोनस के रूप में, क्या इस तरह से dtypes को संरक्षित करना संभव है?

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

या इसी के समान?

— mister.nobody.nz
स्रोत

5

आप इसकी आवश्यकता क्यों है ? किसी भी तरह से एफ़पी सरणियों पर आधारित डेटाफ़्रेम नहीं हैं? आपको एक डेटाफ्रेम का उपयोग करने में सक्षम होना चाहिए जहां आपको एक सुन्न सरणी की आवश्यकता होती है। यही कारण है कि आप डेटाफ्रेम का उपयोग स्किकिट के साथ कर सकते हैं-सीखें जहां फ़ंक्शन संख्यात्मक सरणियों के लिए पूछते हैं।

— chrisfs

यहाँ dtypes और recarrays (उर्फ रिकॉर्ड सरणियों या संरचित सरणियों) के बारे में संभवतः प्रासंगिक लिंक के एक जोड़े हैं: (1) stackoverflow.com/questions/9949427/… (2) stackoverflow.com/questions/52579601/…

— JohnE

नोट: पंडों DataFrame को एक सरणी (या सूची) में बदलना इस तरह से अन्य मुद्दों का संकेत हो सकता है। मैं दृढ़ता से यह सुनिश्चित करने की सलाह देता हूं कि एक DataFrame आपके विशेष उपयोग के मामले के लिए उपयुक्त डेटा संरचना है, और यह कि पंडों को आपके द्वारा रुचि रखने वाले कार्यों को करने का कोई तरीका शामिल नहीं है।

— AMC

390

एक पांडा डेटाफ़्रेम (df) को एक सुन्न ndarray में बदलने के लिए, इस कोड का उपयोग करें:

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

— User456898
स्रोत

237

के अपने उपयोग को कम `values`और `as_matrix()`!

पांडा v0.24.0 ने पांडा की वस्तुओं से NumPy सरणियों को प्राप्त करने के लिए दो नए तरीके पेश किए:

to_numpy(), जिस पर परिभाषित किया गया है Index , Series,और DataFrameवस्तुओं, और
array, जो केवल Indexऔर Seriesवस्तुओं पर परिभाषित किया गया है ।

यदि आप v0.24 डॉक्स पर जाते हैं .values, तो आपको एक बड़ी लाल चेतावनी दिखाई देगी जो कहती है:

चेतावनी: हम DataFrame.to_numpy()इसके बजाय उपयोग करने की सलाह देते हैं ।

V0.24.0 जारी नोटों के इस भाग को देखें , और यह उत्तर दें अधिक जानकारी के लिए ।

बेहतर संगति की ओर: `to_numpy()`

पूरे एपीआई में बेहतर स्थिरता की भावना में, एक नई विधि to_numpy डेटाफ्रेम से अंतर्निहित न्यूमरी सरणी को निकालने के लिए पेश किया गया है।

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

जैसा कि ऊपर उल्लेख किया गया है, यह विधि भी Indexऔर Seriesवस्तुओं ( यहां देखें) पर परिभाषित की गई है ) ।

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

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

डिफ़ॉल्ट रूप से, एक दृश्य लौटाया जाता है, इसलिए किए गए किसी भी संशोधन से मूल प्रभावित होगा।

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

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

यदि आपको इसके बजाय प्रतिलिपि की आवश्यकता है, तो उपयोग करें to_numpy(copy=True )।

पांडा> = एक्सटेंशनटेप्स के लिए 1.0 अपडेट

यदि आप पांडा 1.x का उपयोग कर रहे हैं, तो संभावना है कि आप एक्सटेंशन प्रकार के साथ बहुत अधिक व्यवहार करेंगे। आपको थोड़ा और सावधान रहना होगा कि ये एक्सटेंशन प्रकार सही रूप से परिवर्तित हो गए हैं।

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

इसे डॉक्स में कहा जाता है ।

अगर आपको जरूरत है `dtypes` ...

जैसा कि एक अन्य उत्तर में दिखाया गया है, DataFrame.to_recordsऐसा करने का एक अच्छा तरीका है।

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

यह to_numpyदुर्भाग्य से नहीं किया जा सकता है । हालांकि, एक विकल्प के रूप में, आप उपयोग कर सकते हैं 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')])

प्रदर्शन के लिहाज से, यह लगभग समान है (वास्तव में, उपयोग rec.fromrecordsकरना थोड़ा तेज है)।

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)

एक नई विधि जोड़ने के लिए तर्क

to_numpy()(इसके अलावा array) दो GitHub मुद्दों GH19954 और GH23623 के तहत चर्चा के परिणामस्वरूप जोड़ा गया था ।

विशेष रूप से, डॉक्स औचित्य का उल्लेख करते हैं:

[...] इसके साथ .valuesयह स्पष्ट नहीं था कि लौटाया गया मूल्य वास्तविक सरणी, इसका कुछ परिवर्तन या पांडा कस्टम सरणियों (जैसे Categorical) में से एक होगा। उदाहरण के लिए, के साथ PeriodIndex, .values एक नया उत्पन्न करता है ndarrayअवधि के लिए हर बार वस्तुओं। [...]

to_numpyएपीआई की स्थिरता को बेहतर बनाने का लक्ष्य है, जो सही दिशा में एक बड़ा कदम है। .valuesवर्तमान संस्करण में पदावनत नहीं किया जाएगा, लेकिन मुझे उम्मीद है कि यह भविष्य में किसी बिंदु पर हो सकता है, इसलिए मैं उपयोगकर्ताओं से आग्रह करूंगा कि जैसे ही आप कर सकते हैं, नए एपीआई की ओर पलायन करें।

अन्य समाधानों की आलोचना

DataFrame.values असंगत व्यवहार है, जैसा कि पहले ही उल्लेख किया गया है।

DataFrame.get_values()बस चारों ओर एक आवरण है DataFrame.values, इसलिए ऊपर कहा गया सब कुछ लागू होता है।

DataFrame.as_matrix()अब पदावनत है, उपयोग नहीं करते!

— cs95
स्रोत

मुझे समझ में नहीं आता है कि पेज के बाद पेज को पढ़ना कैसे संभव है, पेज के बाद लोग अपने फेफड़ों के शीर्ष पर चिल्लाते हुए as_matrixदूसरे समाधान से स्विच करते हैं, इस मामले में, to_numpyयह बताए बिना कि स्तंभ की कार्यक्षमता को कैसे पुनर्प्राप्त करना है as_matrix! मुझे यकीन है कि स्तंभों का चयन करने के अन्य तरीके हैं, लेकिन as_matrixउनमें से कम से कम एक था!

— जेरी

@ Jérémie के अलावा स्पष्ट df[[col1, col2']].to_numpy()? निश्चित नहीं है कि आप क्यों सोचते हैं कि एक अपग्रेड किए गए फंक्शन वारंट के अपडेटेड विकल्प को विज्ञापित करना चाहते हैं, जो उत्तर पर एक डाउनवोट है।

— cs95

क्या होगा यदि कुछ कॉलम सूची प्रकार के हैं। मैं इसमें से एक सपाट ऊबड़ खाबड़ सरणी कैसे बना सकता हूं?

— मोनिबा

@Moniba आप अपनी आवश्यकता के अनुसार सूची आइटम को अलग कॉलम / पंक्तियों में विस्फोट करना चाहते हैं।

— cs95

जब तक मैं गलत हूं, एक ही कॉल में एक से अधिक कॉलम प्राप्त करने से सभी डेटा एक बड़े सरणी में विलय हो जाते हैं। क्या मैं कुछ भूल रहा हूँ?

— एंड्रिया मोरो

128

नोट : .as_matrix()इस उत्तर में प्रयुक्त विधि को पदावनत किया जाता है। पंडों 0.23.4 चेतावनी:

.as_matrixभविष्य के संस्करण में विधि को हटा दिया जाएगा। इसके बजाय .values का उपयोग करें।

पंडों ने बनाया कुछ ...

numpy_matrix = df.as_matrix()

देता है

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

— ZJS
स्रोत

30

यह एक संरचित सरणी नहीं देता है, सभी कॉलम dtype के हैं object।

— sebix

14

"संस्करण 0.23.0 के बाद से हटा दिया गया: इसके बजाय DataFrame.values का उपयोग करें।" / "यह विधि पश्चगामी संगतता के लिए प्रदान की गई है। आम तौर पर, '.values' का उपयोग करने की सिफारिश की जाती है।" - github.com/pandas-dev/pandas/blob/…

— डेविड जे

4

अब यह पदावनत हो गया है। V0.24 के बाद से, to_numpyबजाय ( .valuesया तो नहीं ) का उपयोग करें । अधिक यहाँ ।

— CS95

1

"FutureWarning: Method .as_matrix भविष्य के संस्करण में हटा दिया जाएगा। इसके बजाय .values का उपयोग करें।"

— फरहाद मालेकी

66

मैं सिर्फ DataFrame.reset_index () और DataFrame.values श्रृंखलाओं को अनुक्रमित सहित डेटाफ्रेम के Numpy प्रतिनिधित्व प्राप्त करने के लिए काम करता हूं :

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

Dtypes प्राप्त करने के लिए हमें इस ndarray को एक संरचित सरणी में दृश्य के रूप में बदलना होगा :

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

— prl900
स्रोत

3

इस उत्तर में केवल एक चीज गायब है कि डेटा फ्रेम से dtype का निर्माण कैसे किया जाता है ताकि आप एक सामान्य कार्य लिख सकें

— जोसेफ गार्विन

32

आप to_recordsविधि का उपयोग कर सकते हैं , लेकिन अगर वे नहीं चाहते हैं कि वे जाने के लिए dtypes के साथ थोड़ा घूमें। मेरे मामले में, आपके DF को एक स्ट्रिंग से कॉपी किया गया है, सूचकांक प्रकार स्ट्रिंग है ( objectपांडा में एक dtype द्वारा दर्शाया गया है):

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

पुनर्विचार dtype परिवर्तित करना मेरे लिए काम नहीं करता है, लेकिन पंडों में पहले से ही ऐसा कर सकते हैं:

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

ध्यान दें कि IDनिर्यात रिकॉर्ड सरणी (एक बग?) में पंडों ने इंडेक्स का नाम ठीक से (से ) निर्धारित नहीं किया है, इसलिए हम टाइप रूपांतरण से लाभ भी उसी के लिए सही करते हैं।

फिलहाल पंडों के पास केवल 8-बाइट पूर्णांक हैं i8, और तैरता है, f8(इस मुद्दे को देखें )।

— Meteore
स्रोत

2

मांगी गई संरचित सरणी (जो कि एक प्रदर्शन से बेहतर प्रदर्शन है) प्राप्त करने के लिए आप बस फिर से निर्माणकर्ता के पास जाते हैं np.array।

— उल्का

हम सिर्फ ऊपर दिखाए गए इंडेक्स का नाम सेट करने के लिए ठीक कर रहे हैं।

— चांग शी

26

ऐसा लगता है कि df.to_records()आपके लिए काम करेगा। आपके द्वारा ढूंढी जा रही सटीक सुविधा का अनुरोध किया गया था और to_recordsविकल्प के रूप में इंगित किया गया था ।

मैंने आपके उदाहरण का उपयोग करते हुए इसे स्थानीय रूप से आज़माया, और उस कॉल की पैदावार आपके द्वारा खोजे जा रहे आउटपुट के समान है।

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

ध्यान दें कि यह एक के recarrayबजाय एक है array। आप इसके निर्माता को कॉल करके परिणाम को नियमित रूप से सुन्न सरणी में ले जा सकते हैं np.array(df.to_records())।

— जेमी डॉयल
स्रोत

3

ठहरिए, @meteore द्वारा अन्य उत्तर की तुलना में इस उत्तर को क्या जोड़ा जाता है जिसका उल्लेख to_records()5 साल पहले किया गया था?

— जॉनई

13

इसे इस्तेमाल करे:

a = numpy.asarray(df)

— दादू खान
स्रोत

नमस्ते! कृपया अपने उत्तर में कुछ स्पष्टीकरण जोड़ें। फिलहाल, यह वर्तमान में लंबाई और सामग्री के कारण समीक्षा द्वारा निम्न गुणवत्ता के रूप में चिह्नित किया जा रहा है और सिस्टम द्वारा हटाए जाने का खतरा है। धन्यवाद!

— d_kennetz

1

मूल रूप से इनपुट को एक सरणी में परिवर्तित करें (जैसा कि नाम से पता चलता है)। तो प्रश्न के संदर्भ के साथ, यह उत्तर मान्य है। check docs.scipy.org/doc/numpy/reference/generated/…

— Lautaro Parada Opazo

धन्यवाद, मुझे लगता है कि यह आत्म-व्याख्यात्मक है।

— दादू खान

8

यहाँ एक पांडा सरणी से एक संरचना सरणी बनाने के लिए मेरा दृष्टिकोण है DataFrame।

डेटा फ़्रेम बनाएं

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

एक पांडा संरचना से एक संख्यात्मक संरचना सरणी (रिकॉर्ड नहीं सरणी) बनाने के लिए फ़ंक्शन को परिभाषित करें 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

reset_indexएक नया डेटा फ़्रेम बनाने के लिए उपयोग करें जिसमें इसके डेटा के भाग के रूप में अनुक्रमणिका शामिल है। उस डेटा फ़्रेम को एक संरचना सरणी में कनवर्ट करें।

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

संपादित करें: अजगर 3. के लिए धन्यवाद के साथ से बचने त्रुटि बुला .encode () को अपडेट किया गया df_to_sarray यूसुफ गार्विन और हेल्सिओन उनकी टिप्पणी और समाधान के लिए।

— फिल
स्रोत

मेरे लिए काम नहीं करता है, त्रुटि: टाइपर्रर: डेटा प्रकार समझ में नहीं आया

— जोसेफ गार्विन

आपकी टिप्पणी के लिए धन्यवाद और सुधार के लिए हसीन को धन्यवाद । मैंने अपना उत्तर अपडेट कर दिया है, इसलिए मुझे उम्मीद है कि यह अब आपके लिए काम करता है।

— फिल

5

डेटा-फ़्रेम को इसके Numpy-array प्रतिनिधित्व में बदलने के दो तरीके।

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

— प्रियांशु चौहान
स्रोत

5

उदाहरण के लिए एक आसान तरीका डेटाफ़्रेम:

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

उपयोग:

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

प्राप्त:

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

— यानि पापदाकिस
स्रोत

4

डेटाफ़्रेम से आर्कगिस टेबल पर निर्यात करते समय और usgs ( https://my.usgs.gov/confluence/display/cdi/pandas.DataFrame+to-ArcGIS+Table ) से समाधान पर बस एक समान समस्या थी । संक्षेप में आपकी समस्या का एक समान समाधान है:

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

— लार्स
स्रोत

4

मैं ऊपर दिए गए उत्तरों से गुजरा। " As_matrix () " विधि काम करती है लेकिन अब अप्रचलित है। मेरे लिए, क्या काम किया गया था " .to_numpy () "।

यह एक बहुआयामी सरणी देता है। यदि आप एक्सेल शीट से डेटा पढ़ रहे हैं और आपको किसी इंडेक्स से डेटा एक्सेस करने की आवश्यकता है तो मैं इस पद्धति का उपयोग करना पसंद करूंगा। उम्मीद है की यह मदद करेगा :)

— Arsam
स्रोत

आपके द्वारा क्या मतलब है और आपको किसी भी सूचकांक से डेटा एक्सेस करने की आवश्यकता है ? आपके डेटा की प्रकृति के आधार पर, पांडस डेटाफ़्रेम पहली जगह में भी सही विकल्प नहीं हो सकता है।

— एएमसी

2

उल्का के जवाब के आगे, मुझे कोड मिला

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

मेरे लिए काम नहीं करता है। इसलिए मैंने इस मुद्दे से चिपके हुए दूसरों की सुविधा के लिए अपना कोड यहाँ रखा।

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

— जेम्स एल
स्रोत

1

डेटाफ्रेम को सुपीरियर एरे में बदलने का एक सरल तरीका:

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

सुसंगतता को बनाए रखने के लिए to_numpy के उपयोग को प्रोत्साहित किया जाता है।

संदर्भ: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_numpy.html

— user1460675
स्रोत

— अरसम

बस एक कोड उदाहरण के साथ इसे और अधिक पूरी तरह से और प्रयोग करने योग्य बनाने की कोशिश की, जो कि मैं व्यक्तिगत रूप से पसंद करता हूं।

— user1460675

1

इसे इस्तेमाल करे:

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)

कुछ और जानकारी: [ https://docs.scipy.org/doc/numpy/reference/generated/numpy.array.html] सुन्न 1.16.5 और पांडा 0.25.2 के लिए मान्य।

— हेर्मेस मोरालेस
स्रोत

पांडा डेटाफ्रेम को न्यूपी सरणी में बदलें

के अपने उपयोग को कम `values`और `as_matrix()`!

चेतावनी: हम `DataFrame.to_numpy()`इसके बजाय उपयोग करने की सलाह देते हैं ।

बेहतर संगति की ओर: `to_numpy()`

पांडा> = एक्सटेंशनटेप्स के लिए 1.0 अपडेट

अगर आपको जरूरत है `dtypes` ...

एक नई विधि जोड़ने के लिए तर्क

अन्य समाधानों की आलोचना

पांडा डेटाफ्रेम को न्यूपी सरणी में बदलें

के अपने उपयोग को कम valuesऔर as_matrix()!

चेतावनी: हम DataFrame.to_numpy()इसके बजाय उपयोग करने की सलाह देते हैं ।

बेहतर संगति की ओर: to_numpy()

पांडा> = एक्सटेंशनटेप्स के लिए 1.0 अपडेट

अगर आपको जरूरत है dtypes ...

एक नई विधि जोड़ने के लिए तर्क

अन्य समाधानों की आलोचना

के अपने उपयोग को कम `values`और `as_matrix()`!

चेतावनी: हम `DataFrame.to_numpy()`इसके बजाय उपयोग करने की सलाह देते हैं ।

बेहतर संगति की ओर: `to_numpy()`

अगर आपको जरूरत है `dtypes` ...