Pandas: बग: कॉनकैट अवांछित रूप से डेटाफ़्रेम कॉलम नामों को सॉर्ट करता है यदि वे भिन्न होते हैं

इसे संक्षेप में देखते हुए मैं _think_ यह Index.intersection से उपजा है, जिसका डॉकस्ट्रिंग कहता है:

दो सूचकांक वस्तुओं के प्रतिच्छेदन का निर्माण करें। परिणाम की क्रमबद्धता की गारंटी नहीं है

सुनिश्चित नहीं है कि वे किन मामलों में दिखाई देते हैं/क्रमबद्ध किए जाते हैं, लेकिन जब कॉलम बराबर होते हैं (आपके पहले वाले में) उसी परिणाम को वापस करने के लिए विशेष रूप से केस किया जाता है ...

@smcierney इसके बजाय आप किस आदेश की अपेक्षा करेंगे?

मैंने पाया कि ऑटो सॉर्ट भी थोड़ा कष्टप्रद था (ठीक है, मुझे कहना चाहिए कि यह आपके उद्देश्य पर निर्भर करता है), क्योंकि मैं एक लूप में एक खाली फ्रेम के लिए एक फ्रेम को समेटने की कोशिश कर रहा था (जैसे किसी सूची में एक तत्व को जोड़ना)। तब मुझे एहसास हुआ कि मेरा कॉलम ऑर्डर बदल गया है। यह परिवर्तन इंडेक्स पर भी लागू होता है, यदि आप अक्ष = 1 के साथ जुड़ रहे हैं।

@smcinerney के समान मामले में, मैं

इसलिए मैंने एक "हैक" लिखा (थोड़े मूर्खतापूर्ण हालांकि)

सॉर्ट किया गया = pd.concat (फ्रेमलिस्ट, अक्ष = अक्ष, शामिल हों = शामिल हों, join_axes = join_axes, अनदेखा_इंडेक्स = गलत, कुंजियाँ = कोई नहीं, स्तर = कोई नहीं, नाम = कोई नहीं, सत्यापित_अखंडता = गलत)

if join_axes:
    return sorted
elif sort:
    return sorted
else:
    # expand all original orders in each frame
    sourceOrder = []
    for frame in frameList:
        sourceOrder.extend(frame.Columns()) if axis == 0 else sourceOrder.extend(frame.Indices())
    sortedOrder = sorted.Columns() if axis == 0 else sorted.Indices()

    positions = []
    positionsSorted = []
    for i in sortedOrder:
        positions.append(sourceOrder.index(i))
        positionsSorted.append(sourceOrder.index(i))
    positionsSorted.sort()

    unsortedOrder = []
    for i in positionsSorted:
        unsortedOrder.append(sortedOrder[positions.index(i)])

    return sorted.ReorderCols(unsortedOrder) if axis == 0 else sorted.ReorderRows(unsortedOrder)

समारोह कुंगफू नामक मेरे व्यक्तिगत मॉड्यूल में शामिल है! कोई भी उपरोक्त एल्गोरिथम को अपना सकता है, या मेरे मॉड्यूल को https://github.com/jerryzhujian9/kungfu पर देख सकता है

अंत में, मैं इस महान मॉड्यूल के लिए विकास टीम के काम की बहुत सराहना करता हूं!

यह व्यवहार वास्तव में काफी अप्रत्याशित है और मैं भी इस पर ठोकर खाई।

 >>> df = pd.DataFrame()

>>> df['b'] = [1,2,3]
>>> df['c'] = [1,2,3]
>>> df['a'] = [1,2,3]
>>> print(df)
   b  c  a
0  1  1  1
1  2  2  2
2  3  3  3

[3 rows x 3 columns]
>>> df2 = pd.DataFrame({'a':[4,5]})
>>> df3 = pd.concat([df, df2])

भोलेपन से कोई उम्मीद करेगा कि स्तंभों का क्रम संरक्षित है। इसके बजाय कॉलम क्रमबद्ध हैं:

>>> print(df3)
   a   b   c
0  1   1   1
1  2   2   2
2  3   3   3
0  4 NaN NaN
1  5 NaN NaN

[5 rows x 3 columns]

इसे मूल स्तंभों के साथ निम्नानुसार पुन: अनुक्रमणित करके ठीक किया जा सकता है:

>>> df4 = df3.reindex_axis(df.columns, axis=1)
>>> print(df4)
    b   c  a
0   1   1  1
1   2   2  2
2   3   3  3
0 NaN NaN  4
1 NaN NaN  5

[5 rows x 3 columns]

फिर भी यह प्रति-सहज लगता है कि यह स्वचालित छँटाई होती है और जहाँ तक मुझे पता है इसे अक्षम नहीं किया जा सकता है।

मैं अभी इस पर भी आया हूं।

new_data = pd.concat([churn_data, numerical_data])

डेटाफ़्रेम का उत्पादन किया:

     churn  Var1  Var10  Var100  Var101 
0      -1   NaN    NaN     NaN     NaN     
1      -1   NaN    NaN     NaN     NaN

संख्यात्मक डेटाफ़्रेम को पहले क्रमबद्ध किए बिना संयोजित किया जाना अधिक स्वाभाविक प्रतीत होगा !!

ठीक है, यह ठीक करने के लिए थोड़ा सा काम है। लेकिन पुल अनुरोध स्वीकार कर लिया!

बस इसी मुद्दे पर ठोकर खाई जब मैं DataFrames को जोड़ रहा था। यदि आप इस मुद्दे के बारे में नहीं जानते हैं तो यह थोड़ा कष्टप्रद है, लेकिन वास्तव में एक त्वरित उपाय है:

कहते हैं कि dfs की एक सूची है DataFrames आप CONCATENATE करना चाहते हैं, तो आप सिर्फ मूल स्तंभ क्रम लेने के लिए और इसे वापस फ़ीड में कर सकते हैं:

df = pd.concat(dfs, axis=0)
df = df[dfs[0].columns]

मेरा मानना ​​है कि append समान व्यवहार का कारण बनता है, FYI करें

यह बोर्ड भर में डिफ़ॉल्ट व्यवहार है। उदाहरण के लिए, यदि आप एक फ़ंक्शन, f, को एक groupby () में लागू करते हैं जो अलग-अलग संख्या में कॉलम लौटाता है, तो दृश्य के पीछे होने वाला संयोजन भी कॉलम को ऑटो-सॉर्ट करता है।

df.groupby(some_ts).apply(f)

शायद इसलिए कि स्तंभों का ज्ञात क्रम व्याख्या के लिए खुला है।

हालांकि, यह मल्टीइंडिसेस और मल्टीइंडिसेस में सभी पदानुक्रमों के लिए भी होता है। तो आप डेटाफ़्रेम को समतल कर सकते हैं जो स्तर 0 कॉलम और सभी बार एक स्तर 1 कॉलम पर सहमत होते हैं, और मल्टीइंडिस के सभी स्तरों को एक स्तर 0 कॉलम के भीतर एक बेमेल के कारण स्वत: क्रमबद्ध किया जाएगा। मुझे नहीं लगता कि यह वांछनीय है।

मुझे मदद करना अच्छा लगेगा, लेकिन दुर्भाग्य से इस मुद्दे को ठीक करना मेरी क्षमता से परे है। सभी की कड़ी मेहनत के लिए धन्यवाद।

इस सुविधा के लिए +1

सहमत, +1। अप्रत्याशित छँटाई मेरे लिए हर समय होती है।

+1, यह एक अप्रिय आश्चर्य था!

+1, मुझे प्रत्येक append बाद कॉलम सॉर्ट करने से नफरत है।

मेरी तरफ से भी +1।

क्योंकि भले ही मैं एक कॉन्सैट के बाद मैन्युअल रूप से फिर से ऑर्डर करना चाहता हूं, जब मैं अपने डेटाफ्रेम में 60 + कॉलम नाम और पदों को प्रिंट करने का प्रयास करता हूं:

 for id, value in enumerate(df.columns):
      print id, value

सभी 60+ कॉलम वर्णानुक्रम में आउटपुट होते हैं, डेटा फ्रेम में उनकी वास्तविक स्थिति नहीं।

तो इसका मतलब है कि कभी भी समवर्ती होने के बाद, मुझे मैन्युअल रूप से 60 स्तंभों की सूची को फिर से क्रमित करने के लिए टाइप करना होगा। आउच।

जबकि मैं यहां हूं, क्या किसी के पास कॉलम नाम और स्थिति को प्रिंट करने का कोई तरीका है जो मुझे याद आ रही है?

इस सुविधा के लिए +1, बस उसी सौदे में खुद भाग गया।

@summerela कॉलम इंडेक्स प्राप्त करें और फिर मूल कॉलम इंडेक्स का उपयोग करके अपने नए

# assuming you have two dataframes, `df_train` & `df_test` (with the same columns) 
# that you want to concatenate

# get the columns from one of them
all_columns = df_train.columns

# concatenate them
df_concat = pd.concat([df_train,
                       df_test])

# finally, re-index the new dataframe using the original column index
df_concat = df_concat.ix[:, all_columns]

इसके विपरीत, यदि आपको स्तंभों के एक छोटे उपसमुच्चय को पुन: अनुक्रमित करने की आवश्यकता है, तो आप मेरे द्वारा बनाए गए इस फ़ंक्शन का उपयोग कर सकते हैं। यह सापेक्ष सूचकांकों के साथ भी काम कर सकता है। उदाहरण के लिए, यदि आप किसी कॉलम को डेटाफ़्रेम के अंत में ले जाना चाहते हैं, लेकिन आप सुनिश्चित नहीं हैं कि आपकी स्क्रिप्ट में पूर्व प्रसंस्करण चरणों के बाद कितने कॉलम रह सकते हैं (उदाहरण के लिए, आप शून्य-भिन्नता वाले कॉलम छोड़ रहे हैं), आप एक सापेक्ष सूचकांक स्थिति को new_indices -> new_indices = [-1] और यह बाकी का ख्याल रखेगा।

def reindex_columns(dframe=None, columns=None, new_indices=None):
    """
    Reorders the columns of a dataframe as specified by
    `reorder_indices`. Values of `columns` should align with their
    respective values in `new_indices`.

    `dframe`: pandas dataframe.

    `columns`: list,pandas.core.index.Index, or numpy array; columns to
    reindex.

    `reorder_indices`: list of integers or numpy array; indices
    corresponding to where each column should be inserted during
    re-indexing.
    """
    print("Re-indexing columns.")
    try:
        df = dframe.copy()

        # ensure parameters are of correct type and length
        assert isinstance(columns, (pd.core.index.Index,
                                    list,
                                    np.array)),\
        "`columns` must be of type `pandas.core.index.Index` or `list`"

        assert isinstance(new_indices,
                          list),\
        "`reorder_indices` must be of type `list`"

        assert len(columns) == len(new_indices),\
        "Length of `columns` and `reorder_indices` must be equal"

        # check for negative values in `new_indices`
        if any(idx < 0 for idx in new_indices):

            # get a list of the negative values
            negatives = [value for value
                         in new_indices
                         if value < 0]

            # find the index location for each negative value in
            # `new_indices`
            negative_idx_locations = [new_indices.index(negative)
                                      for negative in negatives]

            # zip the lists
            negative_zipped = list(zip(negative_idx_locations,
                                       negatives))

            # replace the negatives in `new_indices` with their
            # absolute position in the index
            for idx, negative in negative_zipped:
                new_indices[idx] = df.columns.get_loc(df.columns[
                                                          negative])

        # re-order the index now
        # get all columns
        all_columns = df.columns

        # drop the columns that need to be re-indexed
        all_columns = all_columns.drop(columns)

        # now re-insert them at the specified locations
        zipped_columns = list(zip(new_indices,
                                  columns))

        for idx, column in zipped_columns:
            all_columns = all_columns.insert(idx,
                                             column)
        # re-index the dataframe
        df = df.ix[:, all_columns]

        print("Successfully re-indexed dataframe.")

    except Exception as e:
        print(e)
        print("Could not re-index columns. Something went wrong.")

    return df

संपादित करें: उपयोग निम्न की तरह दिखेगा:

# move 'Column_1' to the end, move 'Column_2' to the beginning
df = reindex_columns(dframe=df,
                     columns=['Column_1', 'Column_2'],
                     new_indices=[-1, 0])

मुझे इसका सामना करना पड़ा (0.13.1 के साथ) एक किनारे के मामले से उल्लेख नहीं किया गया है: प्रत्येक अद्वितीय कॉलम वाले डेटाफ्रेम का संयोजन। स्तंभ नामों का एक सरल पुन: असाइनमेंट काम नहीं किया:

dat = pd.concat([out_dust, in_dust, in_air, out_air])
dat.columns = [out_dust.columns + in_dust.columns + in_air.columns + out_air.columns]

कॉलम अभी भी क्रमबद्ध हो जाते हैं। सूचियों का उपयोग करते हुए मध्यवर्ती रूप से हल की गई चीजें, हालांकि:

संपादित करें: मैंने बहुत जल्दी बात की ..

अनुवर्ती: fwiw, स्तंभ क्रम को एकवचन वस्तुओं पर जंजीर .join कॉल के साथ संरक्षित किया जा सकता है:

df1.join([df2, df3]) # sorts columns
df1.join(df2).join(df3) # column order retained

कॉलम ऑर्डर करने के बारे में डेटाफ़्रेम बनाते समय कोई पैरामीटर हो सकता है? आदेश की तरह = झूठा। बहुत - बहुत धन्यवाद

एक शब्दकोश से डेटाफ्रेम बनाते समय बस इसमें भाग गया। मुझे पूरी तरह से आश्चर्यचकित कर दिया, प्रतिवाद किया और मेरे पूरे उद्देश्य को हरा दिया ...

कॉलम नाम स्पष्टता के लिए होने चाहिए और एक दूसरे के पास कॉलम का स्थान सुसंगतता बनाए रखने के लिए उपयोगकर्ता की एक संगठनात्मक पसंद है

@patricktokeeffe
सूचक के लिए join के लिए धन्यवाद। श्रृंखला वस्तुओं में वह विधि नहीं है इसलिए मैंने एक फ़ंक्शन लिखना समाप्त कर दिया:

def concat_fixed(ndframe_seq, **kwargs):
    """Like pd.concat but fixes the ordering problem.

    Converts Series objects to DataFrames to access join method
    Use kwargs to pass through to repeated join method
    """
    indframe_seq = iter(ndframe_seq)
    # Use the first ndframe object as the base for the final
    final_df = pd.DataFrame(next(indframe_seq))
    for dataframe in indframe_seq:
        if isinstance(dataframe, pd.Series):
            dataframe = pd.DataFrame(dataframe)
        # Iteratively build final table
        final_df = final_df.join(dataframe, **kwargs)
    return final_df

इस पर दक्षता कैसी है?

बुधवार, 30 अगस्त, 2017 दोपहर 1:58 बजे, ब्राइस गुंटा सूचनाएं @github.com
लिखा था:

@patricktokeeffe https://github.com/patricktokeeffe
शामिल होने के लिए सूचक के लिए धन्यवाद। श्रृंखला वस्तुओं में वह विधि नहीं होती है
मैंने एक समारोह लिखना समाप्त कर दिया:

def concat_fixed (ndframe_seq, **kwargs):
"""pd.concat की तरह लेकिन आदेश देने की समस्या को ठीक करता है।

Converts Series objects to DataFrames to access join method
Use kwargs to pass through to repeated join method
"""
indframe_seq = iter(ndframe_seq)
# Use the first ndframe object as the base for the final
final_df = pd.DataFrame(next(indframe_seq))
for dataframe in indframe_seq:
    if isinstance(dataframe, pd.Series):
        # Convert Series objects into DataFrames since
        # series objects do not have a join method
        dataframe = pd.DataFrame(dataframe)
    # Iteratively build final table
    final_df = final_df.join(dataframe, **kwargs)
return final_df

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने टिप्पणी की थी।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/pandas-dev/pandas/issues/4588#issuecomment-326086636 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/AG999MucF-NH5vHuKe-Zczq-jy9ziYkRks5sdbDogaJpZM4A6TeA
.

@माइकटैम1021

मैं इसे एटीएम बेंचमार्क नहीं करने जा रहा हूं, लेकिन मुझे लगता है कि यह आपके एनडीफ्रेम के आकार, उनकी मात्रा का एक कार्य होगा। यह प्रत्येक ndframe के लिए एक नया डेटाफ़्रेम बनाता है, इसलिए मुझे लगता है कि यह pd.concat तुलना में बहुत कम कुशल है।

यह मेरी प्रयोजनों के लिए ठीक काम करता है, लेकिन मैं की एक छोटी राशि का उपयोग कर रहा ndframes ⁽¹ लगभग 10) और के अपेक्षाकृत छोटी राशि records प्रत्येक ndframe ⁽² चारों ओर 10) के लिए।

मेरा लक्ष्य उन अभिलेखों के क्रम को संरक्षित करते हुए प्रत्येक डेटाफ़्रेम से सभी रिकॉर्ड शामिल करना है, भले ही सभी ndframes में किसी दिए गए रिकॉर्ड के लिए डेटा न हो।

मैं नहीं देख सकता कि कॉलम ऑर्डर को संरक्षित करना (जितना संभव हो) कॉन्सैट() का डिफ़ॉल्ट व्यवहार नहीं है।

मेरा समाधान unique_everseen Itertools Recipes से उपयोग करता है।

columns = unique_everseen([column for df in dfs for column in df.columns])
df = pd.concat(dfs)[columns]

इस थ्रेड की स्थिति पर कोई अपडेट? मैं वर्तमान में संस्करण 0.22.0 का उपयोग कर रहा हूं और अभी भी कोई उचित समाधान नहीं है। विलंब यहाँ काफी एक मुद्दा प्रतीत होता है ...

मैं यह भी नोट करना चाहूंगा कि समान व्यवहार कॉलम को जोड़ते समय पाया जा सकता है, यानी axis=1 , लेकिन केवल एक शब्दकोश में डेटाफ्रेम पास करते समय:

>>> df4a = DataFrame(columns=['C','B','D','A'], data=np.random.randn(3,4))
>>> df4b = DataFrame(columns=['C','B','D','A'], data=np.random.randn(3,4))
>>> df5  = DataFrame(columns=['C','B','E','D','A'], data=np.random.randn(3, 5))

>>> pd.concat([df4a, df5], axis=1).columns
Index(['C', 'B', 'D', 'A', 'C', 'B', 'E', 'D', 'A'], dtype='object')
>>> pd.concat({'df4a': df4a, 'df4b': df4b}, axis=1).columns.levels
FrozenList([['df4a', 'df4b'], ['C', 'B', 'D', 'A']])
>>> pd.concat({'df4a': df4a, 'df5': df5}, axis=1).columns.levels
FrozenList([['df4a', 'df5'], ['A', 'B', 'C', 'D', 'E']])

इस थ्रेड की स्थिति पर कोई अपडेट?

अभी भी खुला।

विलंब यहाँ काफी एक मुद्दा प्रतीत होता है ...

टालमटोल? हमारे पास बहुत सारे खुले मुद्दे हैं। यदि आप यह सुनिश्चित करना चाहते हैं कि यह अगली रिलीज़ में ठीक हो जाए तो आप एक पीआर को एक साथ रखना सबसे अच्छा शर्त है। अगर आपको शुरू करने में मदद चाहिए तो हमें बताएं।

@jtratner : यदि यह शीर्ष पर मेरे उदाहरणों से स्पष्ट नहीं था, तो मैं आदेश की अपेक्षा करता हूं:

• साझा किए गए कॉलम, बिना क्रम के
• df1 के लिए अद्वितीय कॉलम, क्रमबद्ध नहीं (अर्थात जिस क्रम में वे df1 में होते हैं)
• df2 के लिए अद्वितीय कॉलम, क्रमबद्ध नहीं (अर्थात जिस क्रम में वे df2 में होते हैं)

यह वही है जो आपको अन्य पैकेजों या भाषाओं में मिलता है, जैसे SQL। अवांछित स्वचालित प्रकार कभी नहीं होना चाहिए। यदि उपयोगकर्ता कॉलम नामों को सॉर्ट करना चाहता है, तो उन्हें मैन्युअल रूप से ऐसा करने दें।

हे दोस्तों, 2 चीजें। 1) पांडा में आपका स्वागत है! मेरा सुझाव है कि शब्दकोशों जैसे अधिक अजगर देशी प्रकारों का उपयोग करें। अजगर (या किसी भी भाषा) को SQL में बदलने की कोशिश करना बंद करें। 2) यह तकनीकी रूप से एक बग नहीं है। यह कोड का सिर्फ एक अवांछित प्रभाव है। आप पैकेज के संदर्भ के बाहर इसे आसानी से दूर कर सकते हैं, और मुझे लगता है कि यही सही उत्तर है जब तक कि यहां कोई इसे अपने ऊपर नहीं लेता।

@ माइकटैम 1021 कृपया बताएं कि पैकेज के संदर्भ के बाहर इसे कैसे दूर किया जाए। धन्यवाद।

मुझे पूरा यकीन है कि इस सूत्र में लोग ठीक यही चर्चा कर रहे हैं। मैं ऊपर बहुत सारे अच्छे समाधान देखता हूं जो काम करना चाहिए।

@ माइकटैम 1021 यह पांडा को एसक्यूएल में बदलने के बारे में नहीं है (स्वर्ग न करे!), लेकिन मैं इससे अधिक सहमत नहीं हो सका:

अवांछित स्वचालित प्रकार कभी नहीं होना चाहिए। यदि उपयोगकर्ता कॉलम नामों को सॉर्ट करना चाहता है, तो उन्हें मैन्युअल रूप से ऐसा करने दें।

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

मैं सहमत हूँ। यह नहीं होना चाहिए। यह कॉलम के लिए एक आदेश भी मानता है, जो SQLish है, न कि शुद्ध कंप्यूटर विज्ञान। आपको वास्तव में पता होना चाहिए कि आप डेटा कहां हैं।

यह और कई अन्य मुद्दों की खोज के बाद मैं शायद ही अब पांडा का उपयोग करता हूं। इसने मुझे एक बेहतर प्रोग्रामर बनाया है।

इस पर +1

यह मेरे लिए काम करता है:

cols = list(df1)+list(df2)
df1 = pd.concat([df1, df2])
df1 = df1.loc[:, cols]

मुझे इस बारे में कुतिया बनना है कि यह पैच कैसे लुढ़का है। आपने एक साथ concat के फ़ंक्शन हस्ताक्षर को बदल दिया है और उपयोग के बारे में एक चेतावनी पेश की है। सभी एक ही प्रतिबद्धता के भीतर।

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

मैं आसानी से पहचान सकता हूं कि चेतावनी कहां से आ रही है, लेकिन मैं सुझाए गए विकल्पों में से कोई भी नहीं जोड़ सकता क्योंकि यह पांडा के पुराने संस्करण को चलाने वाले किसी भी सर्वर पर प्रोग्राम को तोड़ देगा।

यह बेहतर होता यदि आप छँटाई क्षमता 0.23 पर रखते, और चेतावनी को कुछ बाद के संस्करण में जोड़ते। मुझे पता है कि यह एक दर्द है, लेकिन यह मान लेना अप्रिय है कि उपयोगकर्ता तुरंत सभी तैनाती को नवीनतम कोड में अपडेट कर सकते हैं।

ऐसा लगता है कि आप इस चेतावनी के लिए केवल एक वैश्विक फ़िल्टर सेट कर सकते हैं और फिर
ड्रॉप करें कि जब सभी को अपग्रेड किया जाता है।

कार्यात्मक रूप से, यह वही सही है?

गुरु, 4 अक्टूबर, 2018 को सुबह 9:18 बजे डेविडएस्कॉट नोटिफिकेशन @github.com ने लिखा:

मुझे इस बारे में कुतिया बनना है कि यह पैच कैसे लुढ़का है। आपके पास
साथ ही साथ कॉनकैट के फंक्शन सिग्नेचर को बदल दिया और पेश किया a
उपयोग की चेतावनी दी। सभी एक ही प्रतिबद्धता के भीतर।

इसके साथ समस्या यह है कि हम कई सर्वरों पर पांडा का उपयोग करते हैं और नहीं कर सकते
गारंटी दें कि सभी सर्वरों के पास पांडा का बिल्कुल समान संस्करण है
बार। इसलिए अब हमारे पास कम तकनीकी उपयोगकर्ता हैं जो कार्यक्रमों से चेतावनियां देख रहे हैं
उन्होंने पहले कभी नहीं देखा है, और अनिश्चित हैं अगर चेतावनी का संकेत है
एक समस्या।

मैं आसानी से पहचान सकता हूं कि चेतावनी कहां से आ रही है, लेकिन मैं नहीं जोड़ सकता
सुझाए गए विकल्पों में से कोई भी क्योंकि यह किसी भी कार्यक्रम को तोड़ देगा
पंडों के पुराने संस्करण को चलाने वाला सर्वर।

यदि आप छँटाई क्षमता को में रखते हैं तो यह बेहतर होगा
0.23, और चेतावनी को कुछ बाद के संस्करण में जोड़ा। मुझे इसका दर्द पता है, लेकिन
यह मान लेना अप्रिय है कि उपयोगकर्ता तुरंत सभी को अपडेट कर सकते हैं
नवीनतम कोड के लिए परिनियोजन।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने खुली/बंद स्थिति को संशोधित किया है।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/pandas-dev/pandas/issues/4588#issuecomment-427036391 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/ABQHItEhYfv5kqB-R-pDX4zyIh45hF7kks5uhhiWgaJpZM4A6TeA
.

@TomAugspurger ऐसे कई तरीके हैं जिनसे हम अपनी तरफ से इससे निपट सकते हैं। निश्चित रूप से चेतावनियों को फ़िल्टर करना एक है। यह बहुत अच्छा नहीं है क्योंकि चेतावनियों के यांत्रिकी फिल्टर थोड़े बदसूरत हैं ...

1. मुझे कई कार्यक्रमों में फ़िल्टर जोड़ना होगा
2. फ़िल्टर करने के लिए एक विशिष्ट चेतावनी निर्दिष्ट करने का एक शानदार तरीका नहीं है:
   
   
   
   • मैं मॉड्यूल और लिनेनो द्वारा फ़िल्टर कर सकता हूं, लेकिन यह एक स्थिर संदर्भ नहीं है,
   
   
   • मैं मॉड्यूल और FutureWarning द्वारा फ़िल्टर कर सकता हूं लेकिन फिर मुझे पांडा से कोई चेतावनी नहीं मिलेगी और अन्य परिवर्तनों से आश्चर्यचकित होगा,
   
   
   • या मैं आपके लंबे बहु-पंक्ति संदेश द्वारा फ़िल्टर कर सकता हूं
   
   
3. और फिर उस फ़िल्टर को बाहर निकालना याद रखें जब सब कुछ अपग्रेड हो जाए और यह अब मायने नहीं रखता।

किसी भी मामले में warnings मॉड्यूल में कमियां निश्चित रूप से कुछ नहीं हैं जो मैं पांडा टीम के पैर में डाल सकता हूं।

न ही यह आपकी गलती है कि हमारे पास एक पुराना सर्वर है जिसे हम आसानी से अपग्रेड नहीं कर सकते हैं, इसलिए यह दूसरी चीज होगी जो मैं कर सकता हूं (बस सभी लानत तैनाती को अपग्रेड करें)। अंतत:, मैं मानता हूं कि मुझे यह करना है और यह मेरी जिम्मेदारी है कि हम अपनी तैनाती को एक साथ रखने का प्रयास करें।

यह मेरे लिए थोड़ा विचित्र लगता है कि आप उपयोगकर्ता के दृश्य अंत व्यवहार में संभावित बदलाव के बारे में इतने चिंतित थे कि आपने इस प्रकार के विकल्प को पहले एक अनिर्दिष्ट एपीआई में जोड़ा था, और फिर भी प्रोग्रामर पर एक चेतावनी फेंक दी है ... दोनों चेतावनी और क्रमबद्ध व्यवहार में प्रस्तावित परिवर्तन मेरी पुस्तक में "उपयोगकर्ता के दृश्य व्यवहार" का गठन करता है, बस अलग-अलग गंभीरता का।

मैंने SO पर संबंधित प्रश्न का उत्तर दिया है।