पायथन पंडस यूजर वार्निंग: सॉर्टिंग क्योंकि नॉन-कॉन्टेनेटेशन एक्सिस एलाइन नहीं किया गया है

92

मैं कुछ कोड अभ्यास कर रहा हूं और उपयोगकर्ता चेतावनी प्राप्त करते हुए डेटा फ़्रेमों का विलय कर रहा हूं

/usr/lib64/python2.7/site-packages/pandas/core/frame.py:6201: FutureWarning: सॉर्टिंग क्योंकि गैर-संघनन अक्ष संरेखित नहीं है। पांडा का भविष्य का संस्करण डिफ़ॉल्ट रूप से क्रमबद्ध नहीं होगा। भविष्य के व्यवहार को स्वीकार करने के लिए, 'सॉर्ट = ट्रू' पास करें। वर्तमान व्यवहार को बनाए रखने और चेतावनी को शांत करने के लिए, सॉर्ट = गलत पास करें

कोड की इन पंक्तियों पर: क्या आप इस चेतावनी का समाधान पाने में मदद कर सकते हैं।

placement_video = [self.read_sql_vdx_summary, self.read_sql_video_km]
placement_video_summary = reduce(lambda left, right: pd.merge(left, right, on='PLACEMENT', sort=False), placement_video)


placement_by_video = placement_video_summary.loc[:, ["PLACEMENT", "PLACEMENT_NAME", "COST_TYPE", "PRODUCT",
                                                     "VIDEONAME", "VIEW0", "VIEW25", "VIEW50", "VIEW75",
                                                     "VIEW100",
                                                     "ENG0", "ENG25", "ENG50", "ENG75", "ENG100", "DPE0",
                                                     "DPE25",
                                                     "DPE50", "DPE75", "DPE100"]]

# print (placement_by_video)

placement_by_video["Placement# Name"] = placement_by_video[["PLACEMENT",
                                                            "PLACEMENT_NAME"]].apply(lambda x: ".".join(x),
                                                                                     axis=1)

placement_by_video_new = placement_by_video.loc[:,
                         ["PLACEMENT", "Placement# Name", "COST_TYPE", "PRODUCT", "VIDEONAME",
                          "VIEW0", "VIEW25", "VIEW50", "VIEW75", "VIEW100",
                          "ENG0", "ENG25", "ENG50", "ENG75", "ENG100", "DPE0", "DPE25",
                          "DPE50", "DPE75", "DPE100"]]

placement_by_km_video = [placement_by_video_new, self.read_sql_km_for_video]
placement_by_km_video_summary = reduce(lambda left, right: pd.merge(left, right, on=['PLACEMENT', 'PRODUCT'], sort=False),
                                       placement_by_km_video)

#print (list(placement_by_km_video_summary))
#print(placement_by_km_video_summary)
#exit()
# print(placement_by_video_new)
"""Conditions for 25%view"""
mask17 = placement_by_km_video_summary["PRODUCT"].isin(['Display', 'Mobile'])
mask18 = placement_by_km_video_summary["COST_TYPE"].isin(["CPE", "CPM", "CPCV"])
mask19 = placement_by_km_video_summary["PRODUCT"].isin(["InStream"])
mask20 = placement_by_km_video_summary["COST_TYPE"].isin(["CPE", "CPM", "CPE+", "CPCV"])
mask_video_video_completions = placement_by_km_video_summary["COST_TYPE"].isin(["CPCV"])
mask21 = placement_by_km_video_summary["COST_TYPE"].isin(["CPE+"])
mask22 = placement_by_km_video_summary["COST_TYPE"].isin(["CPE", "CPM"])
mask23 = placement_by_km_video_summary["PRODUCT"].isin(['Display', 'Mobile', 'InStream'])
mask24 = placement_by_km_video_summary["COST_TYPE"].isin(["CPE", "CPM", "CPE+"])

choice25video_eng = placement_by_km_video_summary["ENG25"]
choice25video_vwr = placement_by_km_video_summary["VIEW25"]
choice25video_deep = placement_by_km_video_summary["DPE25"]

placement_by_km_video_summary["25_pc_video"] = np.select([mask17 & mask18, mask19 & mask20, mask17 & mask21],
                                                  [choice25video_eng, choice25video_vwr, choice25video_deep])


"""Conditions for 50%view"""
choice50video_eng = placement_by_km_video_summary["ENG50"]
choice50video_vwr = placement_by_km_video_summary["VIEW50"]
choice50video_deep = placement_by_km_video_summary["DPE50"]

placement_by_km_video_summary["50_pc_video"] = np.select([mask17 & mask18, mask19 & mask20, mask17 & mask21],
                                                  [choice50video_eng,
                                                   choice50video_vwr, choice50video_deep])

"""Conditions for 75%view"""

choice75video_eng = placement_by_km_video_summary["ENG75"]
choice75video_vwr = placement_by_km_video_summary["VIEW75"]
choice75video_deep = placement_by_km_video_summary["DPE75"]

placement_by_km_video_summary["75_pc_video"] = np.select([mask17 & mask18, mask19 & mask20, mask17 & mask21],
                                                  [choice75video_eng,
                                                   choice75video_vwr,
                                                   choice75video_deep])

"""Conditions for 100%view"""

choice100video_eng = placement_by_km_video_summary["ENG100"]
choice100video_vwr = placement_by_km_video_summary["VIEW100"]
choice100video_deep = placement_by_km_video_summary["DPE100"]
choicecompletions = placement_by_km_video_summary['COMPLETIONS']

placement_by_km_video_summary["100_pc_video"] = np.select([mask17 & mask22, mask19 & mask24, mask17 & mask21, mask23 & mask_video_video_completions],
                                                          [choice100video_eng, choice100video_vwr, choice100video_deep, choicecompletions])



"""conditions for 0%view"""

choice0video_eng = placement_by_km_video_summary["ENG0"]
choice0video_vwr = placement_by_km_video_summary["VIEW0"]
choice0video_deep = placement_by_km_video_summary["DPE0"]

placement_by_km_video_summary["Views"] = np.select([mask17 & mask18, mask19 & mask20, mask17 & mask21],
                                                   [choice0video_eng,
                                                    choice0video_vwr,
                                                    choice0video_deep])


#print (placement_by_km_video_summary)
#exit()

#final Table

placement_by_video_summary = placement_by_km_video_summary.loc[:,
                             ["PLACEMENT", "Placement# Name", "PRODUCT", "VIDEONAME", "COST_TYPE",
                              "Views", "25_pc_video", "50_pc_video", "75_pc_video","100_pc_video",
                              "ENGAGEMENTS","IMPRESSIONS", "DPEENGAMENTS"]]

#placement_by_km_video = [placement_by_video_summary, self.read_sql_km_for_video]
#placement_by_km_video_summary = reduce(lambda left, right: pd.merge(left, right, on=['PLACEMENT', 'PRODUCT']),
                                       #placement_by_km_video)


#print(placement_by_video_summary)
#exit()
# dup_col =["IMPRESSIONS","ENGAGEMENTS","DPEENGAMENTS"]

# placement_by_video_summary.loc[placement_by_video_summary.duplicated(dup_col),dup_col] = np.nan

# print ("Dhar",placement_by_video_summary)

'''adding views based on conditions'''
#filter maximum value from videos

placement_by_video_summary_new = placement_by_km_video_summary.loc[
    placement_by_km_video_summary.reset_index().groupby(['PLACEMENT', 'PRODUCT'])['Views'].idxmax()]
#print (placement_by_video_summary_new)
#exit()
# print (placement_by_video_summary_new)
# mask22 = (placement_by_video_summary_new.PRODUCT.str.upper ()=='DISPLAY') & (placement_by_video_summary_new.COST_TYPE=='CPE')

placement_by_video_summary_new.loc[mask17 & mask18, 'Views'] = placement_by_video_summary_new['ENGAGEMENTS']
placement_by_video_summary_new.loc[mask19 & mask20, 'Views'] = placement_by_video_summary_new['IMPRESSIONS']
placement_by_video_summary_new.loc[mask17 & mask21, 'Views'] = placement_by_video_summary_new['DPEENGAMENTS']

#print (placement_by_video_summary_new)
#exit()
placement_by_video_summary = placement_by_video_summary.drop(placement_by_video_summary_new.index).append(
    placement_by_video_summary_new).sort_index()

placement_by_video_summary["Video Completion Rate"] = placement_by_video_summary["100_pc_video"] / \
                                                      placement_by_video_summary["Views"]

placement_by_video_final = placement_by_video_summary.loc[:,
                           ["Placement# Name", "PRODUCT", "VIDEONAME", "Views",
                            "25_pc_video", "50_pc_video", "75_pc_video", "100_pc_video",
                            "Video Completion Rate"]]
python  pandas 
— MishD
स्रोत

जवाबों:

135

tl; डॉ:

concatऔर appendयदि स्तंभ मेल नहीं खाते हैं, तो वर्तमान में गैर-अनुक्रमण इंडेक्स (जैसे कॉलम यदि आप पंक्तियों को जोड़ रहे हैं) को सॉर्ट करें। पांडा 0.23 में इसने एक चेतावनी उत्पन्न करना शुरू कर दिया; sort=Trueइसे चुप कराने के लिए पैरामीटर पास करें । भविष्य में डिफ़ॉल्ट को सॉर्ट करने के लिए नहीं बदलेगा , इसलिए sort=Trueया तो यह निर्दिष्ट करना सबसे अच्छा है या Falseअभी तक, यह सुनिश्चित करना बेहतर है कि आपके गैर-संघातन सूचकांकों का मिलान हो।

पांडा 0.23.0 में चेतावनी नई है :

पांडा के भविष्य के संस्करण में pandas.concat()और DataFrame.append()अब गैर-संघनन अक्ष को नहीं छाँटेगा जब यह पहले से ही संरेखित नहीं है। वर्तमान व्यवहार पिछले (सॉर्टिंग) के समान है, लेकिन अब एक चेतावनी जारी की जाती है जब सॉर्ट निर्दिष्ट नहीं किया जाता है और गैर-संघनन अक्ष संरेखित नहीं किया जाता है, लिंक ।

लिंक बहुत पुराने github मुद्दे से अधिक जानकारी , smcinerney द्वारा टिप्पणी :

जब DataFrames को सम्‍मिलित करते हैं, तो कॉलम नाम अल्फ़ान्यूमेरिक रूप से सॉर्ट किए जाते हैं यदि उनके बीच कोई अंतर हो। यदि वे डेटाफ़्रेम में समान हैं, तो वे सॉर्ट नहीं किए जाते हैं।

यह प्रकार अनिर्धारित और अवांछित है। निश्चित रूप से डिफ़ॉल्ट व्यवहार नो-सॉर्ट होना चाहिए।

कुछ समय के बाद पैरामीटर sortमें लागू किया गया था pandas.concatऔर DataFrame.append:

तरह : बूलियन, डिफ़ॉल्ट कोई नहीं

गैर-संघनन अक्ष को सॉर्ट करें यदि यह 'बाहरी' होने पर पहले से संरेखित न हो। छंटनी का वर्तमान डिफ़ॉल्ट पदावनत है और भविष्य के पांडा के संस्करण में छँटाई नहीं करने के लिए बदल जाएगा।

स्पष्ट रूप से पास करना = चेतावनी और सॉर्ट करने के लिए सही। स्पष्ट रूप से पास करना = चेतावनी को चुप करने के लिए गलत और न छाँटना।

जुड़ने पर इसका कोई प्रभाव नहीं है = 'आंतरिक', जो पहले से ही गैर-संघनन अक्ष के आदेश को संरक्षित करता है।

इसलिए यदि दोनों डेटाफ्रेम में समान क्रम में समान कॉलम हैं, तो कोई चेतावनी नहीं है और कोई छंटनी नहीं है:

df1 = pd.DataFrame({"a": [1, 2], "b": [0, 8]}, columns=['a', 'b'])
df2 = pd.DataFrame({"a": [4, 5], "b": [7, 3]}, columns=['a', 'b'])

print (pd.concat([df1, df2]))
   a  b
0  1  0
1  2  8
0  4  7
1  5  3

df1 = pd.DataFrame({"a": [1, 2], "b": [0, 8]}, columns=['b', 'a'])
df2 = pd.DataFrame({"a": [4, 5], "b": [7, 3]}, columns=['b', 'a'])

print (pd.concat([df1, df2]))
   b  a
0  0  1
1  8  2
0  7  4
1  3  5

लेकिन अगर DataFrames के अलग-अलग कॉलम होते हैं, या एक ही कॉलम एक अलग क्रम में होता है, तो पैंडस एक चेतावनी देता है यदि कोई पैरामीटर sortस्पष्ट रूप से सेट नहीं है ( sort=Noneडिफ़ॉल्ट मान है):

df1 = pd.DataFrame({"a": [1, 2], "b": [0, 8]}, columns=['b', 'a'])
df2 = pd.DataFrame({"a": [4, 5], "b": [7, 3]}, columns=['a', 'b'])

print (pd.concat([df1, df2]))

FutureWarning: सॉर्टिंग क्योंकि गैर-संघनन अक्ष संरेखित नहीं है।

   a  b
0  1  0
1  2  8
0  4  7
1  5  3

print (pd.concat([df1, df2], sort=True))
   a  b
0  1  0
1  2  8
0  4  7
1  5  3

print (pd.concat([df1, df2], sort=False))
   b  a
0  0  1
1  8  2
0  7  4
1  3  5

DataFrames विभिन्न स्तंभों है, लेकिन पहले कॉलम गठबंधन कर रहे हैं - वे सही ढंग से एक दूसरे को (स्तंभों को सौंपा जाएगा aऔर bसे df1साथ aऔर bसेdf2 नीचे दिए गए उदाहरण में), क्योंकि वे दोनों में मौजूद हैं। अन्य स्तंभों के लिए जो एक नहीं बल्कि दोनों DataFrames में मौजूद हैं, लापता मान बनाए जाते हैं।

अंत में, यदि आप पास होते हैं sort=True, तो कॉलम अल्फ़ान्यूमेरिक रूप से सॉर्ट किए जाते हैं। यदि sort=Falseदूसरे DafaFrame में ऐसे कॉलम हैं जो पहले नहीं हैं, तो उन्हें अंत में बिना किसी छांटे के जोड़ा जाता है:

df1 = pd.DataFrame({"a": [1, 2], "b": [0, 8], 'e':[5, 0]}, 
                    columns=['b', 'a','e'])
df2 = pd.DataFrame({"a": [4, 5], "b": [7, 3], 'c':[2, 8], 'd':[7, 0]}, 
                    columns=['c','b','a','d'])

print (pd.concat([df1, df2]))

FutureWarning: सॉर्टिंग क्योंकि गैर-संघनन अक्ष संरेखित नहीं है।

   a  b    c    d    e
0  1  0  NaN  NaN  5.0
1  2  8  NaN  NaN  0.0
0  4  7  2.0  7.0  NaN
1  5  3  8.0  0.0  NaN

print (pd.concat([df1, df2], sort=True))
   a  b    c    d    e
0  1  0  NaN  NaN  5.0
1  2  8  NaN  NaN  0.0
0  4  7  2.0  7.0  NaN
1  5  3  8.0  0.0  NaN

print (pd.concat([df1, df2], sort=False))

   b  a    e    c    d
0  0  1  5.0  NaN  NaN
1  8  2  0.0  NaN  NaN
0  7  4  NaN  2.0  7.0
1  3  5  NaN  8.0  0.0

आपके कोड में:

placement_by_video_summary = placement_by_video_summary.drop(placement_by_video_summary_new.index)
                                                       .append(placement_by_video_summary_new, sort=True)
                                                       .sort_index()
— jezrael
स्रोत
21
मुझे यह बिल्कुल समझ में नहीं आ रहा है: In a future version of pandas pandas.concat() and DataFrame.append() will no longer sort the non-concatenation axis when it is not already aligned. एक क्या है non-concatenation axisऔर परिणाम कैसा दिखेगा? कॉलम a और कॉलम b बेमेल होगा? या सिर्फ कॉलम ऑर्डर अलग है?
— एक प्रस्ताव
9
यह स्पष्ट नहीं है कि is not alignedइसका क्या मतलब है - क्या आप उस पर टिप्पणी कर सकते हैं?
— Mr_and_Mrs_D
1
मेरा मानना alignedहै कि अक्ष में स्तर समान हैं: यदि किसी प्रकार का अंतर है, तो वे अब नहीं हैं alignedऔर इस व्यवहार को ट्रिगर करेंगे (जैसे यदि अक्ष स्तर हैं ['c','b','a']और ['a'])
— रॉबर्ट मुइल
3
@RobertMuil मुझे लगता है कि levelयहां शब्द का उपयोग संभावित रूप से भ्रामक है क्योंकि levelमल्टीएंडेक्स होने पर पांडा डेटाफ़ॉर्म के लिए एक विशिष्ट अर्थ है। alignedइस संदर्भ में मैं जो समझता हूं, वह पंक्ति / स्तंभ सूचकांक के क्रम को संदर्भित करता है। इसलिए यदि आपके दोनों फ़्रेमों के लिए गैर-संघनन अक्ष सूचकांक क्रम अलग है, तो आप निर्दिष्ट कर सकते हैं कि क्या पहले फ्रेम में आदेश को बनाए रखना है, और दूसरे फ्रेम को मिलान करने के लिए सॉर्ट करना है, या कंक्रीटिंग से पहले बीओटीएच फ्रेम के सूचकांक को सॉर्ट करना है। यह मेरे लिए एक भ्रामक क्षेत्र है इसलिए भी सुधारों का स्वागत है!
— 14:24 पर ac24
जब कॉलम जोड़े जाते हैं tuple(df1.columns) == tuple(df2.columns)। गैर-संघनन अक्ष सीमों के समानांतर अक्ष (पंक्तियाँ या स्तंभ) हैं जिनके साथ DataFrames को एक साथ सिलाई किया जा रहा है।
— बॉलपॉइंटबैन
107

jezrael का उत्तर अच्छा है, लेकिन मेरे पास एक प्रश्न का उत्तर नहीं है: क्या "सॉर्ट" फ़्लैग गलत होने से मेरे डेटा में किसी भी तरह से गड़बड़ी होगी? जवाब स्पष्ट रूप से "नहीं" है, आप किसी भी तरह से ठीक हैं।

from pandas import DataFrame, concat

a = DataFrame([{'a':1,      'c':2,'d':3      }])
b = DataFrame([{'a':4,'b':5,      'd':6,'e':7}])

>>> concat([a,b],sort=False)
   a    c  d    b    e
0  1  2.0  3  NaN  NaN
0  4  NaN  6  5.0  7.0

>>> concat([a,b],sort=True)
   a    b    c  d    e
0  1  NaN  2.0  3  NaN
0  4  5.0  NaN  6  7.0
— RLC
स्रोत
क्या वास्तव में उसकी छँटाई हुई है या नहीं छाँटी गई है?
— बेन
2
@ चेतावनी तब प्रकट होती है जब डेटाफ़्रेम के बीच कॉलम क्रम अलग होता है। जैसा कि आप देख सकते हैं कि क्या सॉर्ट = सही है, तो
— समवर्ती के
इस उदाहरण में यह नहीं है, लेकिन यदि आप एक डेटाइमइंडेक्स के साथ कई श्रृंखला या डेटाफ्रेम को संक्षिप्त करते हैं तो पंक्तियाँ कालानुक्रमिक क्रम में नहीं हैं। तकनीकी रूप से डेटा गड़बड़ नहीं है, लेकिन आपका परिणाम पढ़ने में कठिन हो सकता है।
— ह्यूगोवडबर्ग
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.