Pandas ट्यूटोरियल: Python में DataFrames

• आप यह भी जानते हैं कि .iloc[] इंडेक्स में स्थितियों को देखेगा। जब आप 2 पास करेंगे, तो आपको यह मिलेगा:

48    7
49    8
50    9संचालित द्वारा

• क्योंकि इंडेक्स केवल पूर्णांकों का नहीं है, .ix[] का व्यवहार iloc जैसा ही होगा और इंडेक्स में स्थितियों को देखेगा। आपको .iloc[] जैसा ही परिणाम मिलेगा।

अब जब .iloc[], .loc[] और .ix[] के बीच का अंतर स्पष्ट है, तो आप अपने DataFrame में पंक्तियाँ जोड़ने के लिए तैयार हैं!

टिप: उपर्युक्त के परिणामस्वरूप, सामान्य सिफारिश यही है कि आप अपने DataFrame में पंक्तियाँ डालने के लिए .loc का उपयोग करें। क्योंकि यदि आप df.ix[] का उपयोग करेंगे, तो संभव है कि आप संख्यात्मक इंडेक्स वैल्यू देकर गलती से किसी मौजूदा पंक्ति को ओवरराइट कर दें। इससे बचें!

नीचे दिए गए DataFrame में अंतर को एक बार फिर देखें:

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), index= [2.5, 12.6, 4.8], columns=[48, 49, 50])

# This will make an index labeled `2` and add the new values
df.loc[2] = [11, 12, 13]
print(df)संचालित द्वारा

     48  49  50

2.5    1   2   3

12.6   4   5   6

4.8    7   8   9

2.0   11  12  13संचालित द्वारा

आप समझ सकते हैं कि यह सब क्यों उलझनभरा हो सकता है, है ना?

अपने DataFrame में कॉलम जोड़ना

कभी-कभी, आप अपना इंडेक्स अपने DataFrame का हिस्सा बनाना चाहते हैं। आप इसे आसानी से कर सकते हैं—अपने DataFrame से किसी कॉलम को लें या ऐसी कॉलम का संदर्भ दें जो अभी बनी नहीं है और उसे .index प्रॉपर्टी को असाइन कर दें, इस तरह:

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['A', 'B', 'C'])
​
# Use `.index`
df['D'] = df.index
​
# Print `df`
print(df)संचालित द्वारा

  A  B  C  D

0  1  2  3  0

1  4  5  6  1

2  7  8  9  2संचालित द्वारा

दूसरे शब्दों में, आप अपने DataFrame से कहते हैं कि उसे कॉलम A को अपना इंडेक्स लेना चाहिए।

हालाँकि, यदि आप अपने DataFrame में कॉलम जोड़ना चाहते हैं, तो आप वही तरीका अपना सकते हैं जैसा आपने इंडेक्स जोड़ते समय किया था: .loc[] या .iloc[] का उपयोग करें। इस मामले में, आप .loc[] की मदद से एक Series को मौजूदा DataFrame में जोड़ते हैं:

# Study the DataFrame `df`
print(df)

# Append a column to `df`
df.loc[:, 4] = pd.Series(['5', '6', '7'], index=df.index)

# Print out `df` again to see the changes
print(df)संचालित द्वारा

  A  B  C  D

0  1  2  3  0

1  4  5  6  1

2  7  8  9  2

   A  B  C  D  4

0  1  2  3  0  5

1  4  5  6  1  6

2  7  8  9  2  7संचालित द्वारा

याद रखें कि Series ऑब्जेक्ट काफी हद तक DataFrame की एक कॉलम जैसा ही होता है। यही कारण है कि आप आसानी से किसी Series को मौजूदा DataFrame में जोड़ सकते हैं। यह भी नोट करें कि .loc[] के बारे में पहले की गई बात कॉलम जोड़ते समय भी मान्य रहती है!

अपने DataFrame का इंडेक्स रीसेट करना

यदि आपका इंडेक्स आपकी इच्छानुसार नहीं दिख रहा, तो आप उसे रीसेट करने का विकल्प चुन सकते हैं। आप इसे आसानी से .reset_index() से कर सकते हैं। हालांकि, सावधान रहें, आप कई आर्ग्युमेंट्स पास कर सकते हैं जो आपके रीसेट की सफलता को बना या बिगाड़ सकते हैं:

# Check out the weird index of your dataframe
print(df)

# Use `reset_index()` to reset the values. 
df_reset = df.reset_index(level=0, drop=True)

# Print `df_reset`
print(df_reset)संचालित द्वारा

  A  B  C  D  4

0  1  2  3  0  5

1  4  5  6  1  6

2  7  8  9  2  7
संचालित द्वारा

   A  B  C  D  4

0  1  2  3  0  5

1  4  5  6  1  6

2  7  8  9  2  7संचालित द्वारा

ऊपर के उदाहरण में drop आर्ग्युमेंट को inplace से बदलकर देखें और देखें क्या होता है!

ध्यान दें कि आप drop आर्ग्युमेंट का उपयोग यह बताने के लिए करते हैं कि आप पहले वाले इंडेक्स से छुटकारा चाहते हैं। यदि आप inplace का उपयोग करते, तो फ़्लोट्स वाला मूल इंडेक्स आपके DataFrame में एक अतिरिक्त कॉलम के रूप में जुड़ जाता।

अपने DataFrame से इंडेक्स हटाना

यदि आप अपने DataFrame से इंडेक्स हटाना चाहते हैं, तो दोबारा सोचें क्योंकि DataFrames और Series के पास हमेशा इंडेक्स होता है।

हालाँकि, जो आप कर सकते हैं, वह उदाहरण के लिए यह है:

• अपने DataFrame का इंडेक्स रीसेट करना (कैसे करना है, यह पिछले सेक्शन में देखें) या
• यदि कोई इंडेक्स नाम है, तो उसे del df.index.name चलाकर हटाना,
• डुप्लिकेट इंडेक्स मानों को इंडेक्स रीसेट करके हटाना, अपने DataFrame में जोड़े गए इंडेक्स कॉलम के डुप्लिकेट्स को ड्रॉप करना और उस बिना-डुप्लिकेट वाले कॉलम को फिर से इंडेक्स बनाना
• और आख़िर में, किसी इंडेक्स—और उसके साथ एक पंक्ति—को हटाना। इसे इस ट्यूटोरियल में आगे विस्तारित किया गया है।

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [40, 50, 60], [23, 35, 37]]), 
                  index= [2.5, 12.6, 4.8, 4.8, 2.5], 
                  columns=[48, 49, 50])
                  
df.reset_index().drop_duplicates(subset='index', keep='last').set_index('index')संचालित द्वारा

अब जब आप जानते हैं कि अपने DataFrame से इंडेक्स कैसे हटाना है, तो आप कॉलम और पंक्तियाँ हटाने पर बढ़ सकते हैं!

अपने DataFrame से कॉलम हटाना

अपने DataFrame से (चुने हुए) कॉलम्स से छुटकारा पाने के लिए, आप drop() मेथड का उपयोग कर सकते हैं:

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['A', 'B', 'C'])

# Check out the DataFrame `df`
print(df)

# Drop the column with label 'A'                  
df.drop('A', axis=1, inplace=True)

# Drop the column at position 1
df.drop(df.columns[[1]], axis=1)संचालित द्वारा

  A  B  C

0  1  2  3

1  4  5  6

2  7  8  9संचालित द्वारा

आप सोच सकते हैं: यह इतना सीधा-सादा नहीं है; drop() मेथड को कुछ अतिरिक्त आर्ग्युमेंट्स पास किए गए हैं!

• axis आर्ग्युमेंट 0 हो तो यह पंक्तियों को और 1 हो तो कॉलम्स को इंगित करता है।
• आप inplace को True पर सेट कर सकते हैं ताकि DataFrame को दोबारा असाइन किए बिना कॉलम डिलीट हो जाए।

अपने DataFrame से पंक्ति हटाना

आप अपने DataFrame से डुप्लिकेट पंक्तियों को df.drop_duplicates() चलाकर हटा सकते हैं। आप ऐसी पंक्तियाँ भी हटा सकते हैं, जहाँ आप केवल किसी एक कॉलम में मौजूद डुप्लिकेट मानों को ध्यान में रखते हैं।

यह उदाहरण देखें:

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [40, 50, 60], [23, 35, 37]]), 
                  index= [2.5, 12.6, 4.8, 4.8, 2.5], 
                  columns=[48, 49, 50])

# Check out your DataFrame `df`
print(df)

# Drop the duplicates in `df`
df.drop_duplicates([48], keep='last')संचालित द्वारा

      48  49  50

2.5    1   2   3

12.6   4   5   6

4.8    7   8   9

4.8   40  50  60

2.5   23  35  37संचालित द्वारा

यदि हटाने के लिए कोई विशिष्ट यूनिकनेस मानदंड नहीं है, तो आप drop() मेथड का उपयोग कर सकते हैं, जहाँ आप index प्रॉपर्टी से यह बताते हैं कि किन पंक्तियों के इंडेक्स आप DataFrame से हटाना चाहते हैं:

# Check out the DataFrame `df`
print(df)

# Drop the index at position 1
df.drop(df.index[1])संचालित द्वारा

     48  49  50

2.5    1   2   3

12.6   4   5   6

4.8    7   8   9

4.8   40  50  60

2.5   23  35  37संचालित द्वारा

इस कमांड के बाद, आप इंडेक्स को फिर से रीसेट करना चाह सकते हैं।

टिप: परिणामस्वरूप DataFrame का इंडेक्स खुद रीसेट करके देखें! यदि आवश्यक लगे तो drop आर्ग्युमेंट का उपयोग करना न भूलें।

DataFrame में किसी स्ट्रिंग की सभी आवृत्तियों को बदलना

अपने DataFrame में कुछ स्ट्रिंग्स को बदलने के लिए, आप आसानी से replace() का उपयोग कर सकते हैं: वे मान पास करें जिन्हें आप बदलना चाहते हैं, और फिर वे मान जिनसे आप उन्हें बदलना चाहते हैं।

इस तरह:

df = pd.DataFrame({"Student1":['OK','Awful','Acceptable'], 
                   "Student2":['Perfect','Awful','OK'], 
                   "Student3":['Acceptable','Perfect','Poor']})

# Study the DataFrame `df` first
print(df)

# Replace the strings by numerical values (0-4)
df.replace(['Awful', 'Poor', 'OK', 'Acceptable', 'Perfect'], [0, 1, 2, 3, 4]) संचालित द्वारा

     Student1 Student2    Student3

0          OK  Perfect  Acceptable

1       Awful    Awful     Perfect

2  Acceptable       OK        Poorसंचालित द्वारा

ध्यान दें कि एक regex आर्ग्युमेंट भी है जो अजीब स्ट्रिंग संयोजनों का सामना करते समय बहुत मदद कर सकता है:

df =  pd.DataFrame([["1\n", 2, "3\n"], [4, 5, "6\n"] ,[7, "8\n", 9]])

# Check out your DataFrame `df`
print(df)

# Replace strings by others with `regex`
df.replace({'\n': ''}, regex=True)संचालित द्वारा

    0    1    2

0  1\n    2  3\n

1    4    5  6\n

2    7  8\n    9संचालित द्वारा

संक्षेप में, जब आप अपने DataFrame में मानों या स्ट्रिंग्स को अन्य मानों से बदलना चाहते हैं, तो replace() अक्सर वही होता है जिसकी आपको ज़रूरत होती है!

अपने DataFrame की कोशिकाओं में स्ट्रिंग्स के हिस्से हटाना

स्ट्रिंग्स के अनचाहे हिस्से हटाना झंझट का काम है। सौभाग्य से, इसका आसान समाधान है!

df =  pd.DataFrame([["+-1aAbBcC", "2", "+-3aAbBcC"], ["4", "5", "+-6aAbBcC"] ,["7", "+-8aAbBcC", "9"]])

# Check out your DataFrame
print(df)

# Delete unwanted parts from the strings in the first column
df[0] = df[0].map(lambda x: x.lstrip('+-').rstrip('aAbBcC'))

# Check out the result again
dfसंचालित द्वारा

          0          1          2

0  +-1aAbBcC          2  +-3aAbBcC

1          4          5  +-6aAbBcC

2          7  +-8aAbBcC          9संचालित द्वारा

आप कॉलम result पर map() का उपयोग करते हैं ताकि लैम्ब्डा फंक्शन को कॉलम के प्रत्येक एलिमेंट पर, यानी एलिमेंट-वाइज, लागू किया जा सके। फंक्शन स्ट्रिंग मान लेता है और बाएँ स्थित + या - को हटाता है, और दाएँ पर मौजूद छह में से कोई भी aAbBcC भी हटा देता है।

DataFrame में किसी कॉलम के टेक्स्ट को कई पंक्तियों में बाँटना

यह कुछ अधिक कठिन फॉर्मैटिंग कार्य है। हालाँकि, अगला कोड खंड आपको चरण-दर-चरण समझाएगा:

df = pd.DataFrame({"Age": [34, 22, 19], 
                   "PlusOne":[0,0,1], 
                   "Ticket":["23:44:55", "66:77:88", "43:68:05 56:34:12"]})

# Inspect your DataFrame `df`
print(df)

# Split out the two values in the third row
# Make it a Series
# Stack the values
ticket_series = df['Ticket'].str.split(' ').apply(pd.Series, 1).stack()

# Get rid of the stack:
# Drop the level to line up with the DataFrame
ticket_series.index = ticket_series.index.droplevel(-1)

print(ticket_series)संचालित द्वारा

  Age  PlusOne             Ticket

0   34        0           23:44:55

1   22        0           66:77:88

2   19        1  43:68:05 56:34:12

0    23:44:55

1    66:77:88

2    43:68:05

2    56:34:12

dtype: object

          0

0  23:44:55

1  66:77:88

2  43:68:05

2  56:34:12संचालित द्वारा

संक्षेप में, आप यह करते हैं:

• पहले, आप उपलब्ध DataFrame का निरीक्षण करते हैं। आप देखते हैं कि आखिरी पंक्ति और आखिरी कॉलम के मान कुछ ज़्यादा लंबे हैं। लगता है दो टिकट हैं क्योंकि किसी अतिथि ने कंसर्ट में प्लस-वन लाया है।
• आप DataFrame df से Ticket कॉलम लेते हैं और स्ट्रिंग्स को स्पेस पर बाँटते हैं। इससे सुनिश्चित होगा कि अंत में दो टिकट अलग-अलग पंक्तियों में आ जाएँ। इसके बाद, आप इन चार मानों (चार टिकट नंबरों) को एक Series ऑब्जेक्ट में डालते हैं:

      0         1
0  23:44:55       NaN
1  66:77:88       NaN
2  43:68:05  56:34:12संचालित द्वारा

• यह अभी भी सही नहीं लगता। इसमें NaN मान हैं! नतीजतन Series में किसी भी NaN को हटाने के लिए आपको उसे stack करना होगा।
• अगला, आप देखते हैं कि आपकी Series स्टैक्ड है।

0  0    23:44:55
1  0    66:77:88
2  0    43:68:05
   1    56:34:12संचालित द्वारा

• यह भी आदर्श नहीं है। इसलिए आप स्तर (level) को ड्रॉप करते हैं ताकि यह DataFrame के साथ लाइन-अप हो जाए:

0    23:44:55
1    66:77:88
2    43:68:05
2    56:34:12
dtype: objectसंचालित द्वारा

• यही वह है जिसकी आपको तलाश थी।
• अपनी Series को DataFrame में बदलें ताकि आप उसे अपने शुरुआती DataFrame से फिर जोड़ सकें। हालाँकि, DataFrame में कोई डुप्लिकेट न हों, इसके लिए आप मूल Ticket कॉलम हटा सकते हैं।

अपने Pandas DataFrame की कॉलम्स या पंक्तियों पर कोई फंक्शन लगाना

आप अपने DataFrame के डेटा को किसी फंक्शन को लागू करके समायोजित करना चाह सकते हैं। आइए अपनी खुद की लैम्ब्डा फंक्शन बनाकर शुरुआत करें:

doubler = lambda x: x*2संचालित द्वारा

टिप: यदि आप Python में फंक्शंस के बारे में और जानना चाहते हैं, तो यह Python functions ट्यूटोरियल देखें।

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['A', 'B', 'C'])

# Study the `df` DataFrame
print(df)

# Apply the `doubler` function to the `A` DataFrame column
df['A'].apply(doubler)
 A  B  C

0  1  2  3

1  4  5  6

2  7  8  9

0     2

1     8

2    14

Name: A, dtype: int64संचालित द्वारा

ध्यान दें कि आप अपने DataFrame की पंक्ति को भी चुन सकते हैं और उस पर doubler लैम्ब्डा फंक्शन लगा सकते हैं। याद रखें कि आप .loc[] या .iloc[] का उपयोग करके किसी पंक्ति को आसानी से चुन सकते हैं।

फिर, आप कुछ इस तरह का निष्पादन करेंगे, इस पर निर्भर करते हुए कि आप अपने इंडेक्स को उसकी स्थिति के आधार पर चुनना चाहते हैं या उसके लेबल के आधार पर:

df.loc[0].apply(doubler)संचालित द्वारा

ध्यान दें कि apply() फंक्शन केवल आपके DataFrame के अक्ष (axis) के साथ doubler फंक्शन लागू करता है। इसका मतलब है कि आप या तो इंडेक्स या कॉलम्स—यानी, पंक्ति या कॉलम—को लक्षित करते हैं।

हालाँकि, यदि आप इसे प्रत्येक एलिमेंट पर, यानी एलिमेंट-वाइज, लागू करना चाहते हैं, तो आप map() फंक्शन का उपयोग कर सकते हैं। आप ऊपर दिए गए कोड खंड में apply() फंक्शन को map() से बदल सकते हैं। यह न भूलें कि मानों को 2 से गुणा करने के लिए आप अभी भी doubler फंक्शन को पास करें।

मान लीजिए आप यह डबलिंग फंक्शन केवल DataFrame की A कॉलम पर नहीं, बल्कि पूरे DataFrame पर लागू करना चाहते हैं। इस स्थिति में, आप applymap() का उपयोग कर सकते हैं ताकि doubler फंक्शन को पूरे DataFrame के हर एलिमेंट पर लागू किया जा सके:

doubled_df = df.applymap(doubler)
print(doubled_df)संचालित द्वारा

   A   B   C

0   2   4   6

1   8  10  12

2  14  16  18संचालित द्वारा

ध्यान दें कि इन मामलों में, हमने लैम्ब्डा फंक्शंस या अनाम फंक्शंस के साथ काम किया है, जो रनटाइम पर बनते हैं। हालाँकि, आप अपना खुद का फंक्शन भी लिख सकते हैं। उदाहरण के लिए:

def doubler(x):
    if x % 2 == 0:
        return x
    else:
        return x * 2

# Use `applymap()` to apply `doubler()` to your DataFrame
doubled_df = df.applymap(doubler)

# Check the DataFrame
print(doubled_df)संचालित द्वारा

   A   B   C

0   2   2   6

1   4  10   6

2  14   8  18संचालित द्वारा

यदि आप Python में नियंत्रण के फ्लो पर अधिक जानकारी चाहते हैं, तो हमारे अन्य संसाधन देख सकते हैं।

अपने DataFrame को पिवोट करना

आप pivot() फंक्शन का उपयोग करके अपने मूल टेबल से एक नई व्युत्पन्न टेबल बना सकते हैं। जब आप इस फंक्शन का उपयोग करते हैं, तो आप तीन आर्ग्युमेंट्स पास कर सकते हैं:

1. values: यह आर्ग्युमेंट आपको यह बताने देता है कि अपने मूल DataFrame के कौन से मान आप अपनी पिवोट टेबल में देखना चाहते हैं।
2. columns: जो कुछ भी आप इसमें पास करते हैं, वह आपकी परिणामी टेबल में कॉलम बन जाएगा।
3. index: जो कुछ भी आप इसमें पास करते हैं, वह आपकी परिणामी टेबल में इंडेक्स बन जाएगा।

# Import pandas
import pandas as pd

# Create your DataFrame
products = pd.DataFrame({'category': ['Cleaning', 'Cleaning', 'Entertainment', 'Entertainment', 'Tech', 'Tech'],
        'store': ['Walmart', 'Dia', 'Walmart', 'Fnac', 'Dia','Walmart'],
        'price':[11.42, 23.50, 19.99, 15.95, 55.75, 111.55],
        'testscore': [4, 3, 5, 7, 5, 8]})

# Use `pivot()` to pivot the DataFrame
pivot_products = products.pivot(index='category', columns='store', values='price')

# Check out the result
print(pivot_products)संचालित द्वारा

store            Dia   Fnac  Walmart

category                            

Cleaning       23.50    NaN    11.42

Entertainment    NaN  15.95    19.99

Tech           55.75    NaN   111.55संचालित द्वारा

जब आप यह स्पष्ट रूप से नहीं भरते कि आप अपनी परिणामी टेबल में किन मानों की अपेक्षा करते हैं, तो आप कई कॉलम्स द्वारा पिवोट करेंगे:

# Import the Pandas library
import pandas as pd
​
# Construct the DataFrame
products = pd.DataFrame({'category': ['Cleaning', 'Cleaning', 'Entertainment', 'Entertainment', 'Tech', 'Tech'],
                       'store': ['Walmart', 'Dia', 'Walmart', 'Fnac', 'Dia','Walmart'],
                       'price':[11.42, 23.50, 19.99, 15.95, 55.75, 111.55],
                       'testscore': [4, 3, 5, 7, 5, 8]})
​
# Use `pivot()` to pivot your DataFrame
pivot_products = products.pivot(index='category', columns='store')
​
# Check out the results
print(pivot_products)

संचालित द्वारा

             price                testscore             

store            Dia   Fnac Walmart       Dia Fnac Walmart

category                                                  

Cleaning       23.50    NaN   11.42       3.0  NaN     4.0

Entertainment    NaN  15.95   19.99       NaN  7.0     5.0

Tech           55.75    NaN  111.55       5.0  NaN     8.0संचालित द्वारा

ध्यान दें कि आपके डेटा में उन कॉलम्स के लिए डुप्लिकेट मानों वाली पंक्तियाँ नहीं होनी चाहिए जिन्हें आप निर्दिष्ट करते हैं। यदि ऐसा है, तो आपको एरर मैसेज मिलेगा। यदि आप अपने डेटा की यूनिकनेस सुनिश्चित नहीं कर सकते, तो आप pivot_table मेथड का उपयोग करना चाहेंगे:

# Import the Pandas library
import pandas as pd

# Your DataFrame
products = pd.DataFrame({'category': ['Cleaning', 'Cleaning', 'Entertainment', 'Entertainment', 'Tech', 'Tech'],
                        'store': ['Walmart', 'Dia', 'Walmart', 'Fnac', 'Dia','Walmart'],
                        'price':[11.42, 23.50, 19.99, 15.95, 19.99, 111.55],
                        'testscore': [4, 3, 5, 7, 5, 8]})

# Pivot your `products` DataFrame with `pivot_table()`
pivot_products = products.pivot_table(index='category', columns='store', values='price', aggfunc='mean')

# Check out the results
print(pivot_products)संचालित द्वारा

store            Dia   Fnac  Walmart

category                            

Cleaning       23.50    NaN    11.42

Entertainment    NaN  15.95    19.99

Tech           19.99    NaN   111.55संचालित द्वारा

ध्यान दें कि pivot_table मेथड को एक अतिरिक्त aggfunc आर्ग्युमेंट दिया जाता है। यह आर्ग्युमेंट इंगित करता है कि आप एक एग्रीगेशन फंक्शन का उपयोग कई मानों को संयोजित करने के लिए करते हैं। इस उदाहरण में आप स्पष्ट रूप से देख सकते हैं कि mean फंक्शन का उपयोग किया गया है।

stack() और unstack() का उपयोग कर अपने Pandas DataFrame को रेशेप करना

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

स्टैकिंग का उल्टा अनस्टैकिंग कहलाता है। stack() की तरह, आप unstack() का उपयोग सबसे भीतरी पंक्ति इंडेक्स को सबसे भीतरी कॉलम इंडेक्स बनाने के लिए करते हैं।

pandas में पिवोटिंग, स्टैकिंग और अनस्टैकिंग की व्याख्या के लिए हमारा Reshaping Data with pandas कोर्स देखें।

melt() के साथ अपने DataFrame को रेशेप करें

Melting उन मामलों में उपयोगी मानी जाती है जहाँ आपके डेटा में एक या अधिक कॉलम्स पहचान-वेरिएबल (identifier variables) होते हैं, जबकि अन्य सभी कॉलम माप-वेरिएबल (measured variables) माने जाते हैं।

ये माप-वेरिएबल्स सभी पंक्ति अक्ष पर “अनपिवोट” हो जाते हैं। यानी, जो माप-वेरिएबल्स पहले DataFrame की चौड़ाई में फैले हुए थे, melt यह सुनिश्चित करता है कि वे अब इसकी ऊँचाई में आ जाएँ। या, दूसरे शब्दों में, आपका DataFrame अब चौड़ा होने के बजाय लंबा हो जाएगा।

नतीजतन, आपके पास दो गैर-आइडेंटिफ़ायर कॉलम होंगे, यानी ‘variable’ और ‘value’।

इसे एक उदाहरण से स्पष्ट करें:

# The `people` DataFrame
people = pd.DataFrame({'FirstName' : ['John', 'Jane'],
                       'LastName' : ['Doe', 'Austen'],
                       'BloodType' : ['A-', 'B+'],
                       'Weight' : [90, 64]})

# Use `melt()` on the `people` DataFrame
print(pd.melt(people, id_vars=['FirstName', 'LastName'], var_name='measurements'))संचालित द्वारा

 FirstName LastName measurements value

0      John      Doe    BloodType    A-

1      Jane   Austen    BloodType    B+

2      John      Doe       Weight    90

3      Jane   Austen       Weight    64संचालित द्वारा

यदि आप अपने डेटा को रेशेप करने के और तरीकों की तलाश में हैं, तो डॉक्यूमेंटेशन देखें।

DataFrame को CSV में आउटपुट करें

DataFrame को CSV फ़ाइल के रूप में लिखने के लिए, आप to_csv() का उपयोग कर सकते हैं:

import pandas as pd
df.to_csv('myDataFrame.csv')संचालित द्वारा

यह कोड काफ़ी सरल दिखता है, लेकिन यहीं अधिकांश लोगों के लिए मुश्किलें शुरू हो जाती हैं, क्योंकि आपके आउटपुट के लिए विशिष्ट आवश्यकताएँ होंगी। शायद आप कॉमा को डिलिमिटर के रूप में नहीं रखना चाहते, या किसी विशेष एनकोडिंग को निर्दिष्ट करना चाहते हैं।

चिंता न करें! आप to_csv() को कुछ अतिरिक्त आर्ग्युमेंट्स पास कर सकते हैं ताकि आपका डेटा आपकी इच्छानुसार आउटपुट हो!

• टैब से डिलिमिट करने के लिए, sep आर्ग्युमेंट का उपयोग करें:

import pandas as pd
df.to_csv('myDataFrame.csv', sep='\t')संचालित द्वारा

• किसी विशेष कैरेक्टर एनकोडिंग का उपयोग करने के लिए, आप encoding आर्ग्युमेंट का उपयोग कर सकते हैं:

import pandas as pd
df.to_csv('myDataFrame.csv', sep='\t', encoding='utf-8')संचालित द्वारा

• इसके अतिरिक्त, आप यह निर्दिष्ट कर सकते हैं कि अपने NaN या missing मानों को कैसे दर्शाना है, हेडर आउटपुट करना है या नहीं, पंक्ति नाम लिखने हैं या नहीं, कंप्रेशन चाहिए या नहीं—आप विकल्पों के बारे में पढ़ सकते हैं।

DataFrame को Excel में लिखना

ठीक उसी तरह जैसे आपने DataFrame को CSV में आउटपुट किया, आप to_excel() का उपयोग करके अपनी टेबल को Excel में लिख सकते हैं। हालाँकि, यह थोड़ा अधिक जटिल है:

import pandas as pd
writer = pd.ExcelWriter('myDataFrame.xlsx')
df.to_excel(writer, 'DataFrame')
writer.save()संचालित द्वारा

ध्यान दें कि, to_csv() की तरह, यहाँ भी आपके पास बहुत से अतिरिक्त आर्ग्युमेंट्स होते हैं जैसे startcol, startrow आदि, ताकि आप अपना डेटा सही तरीके से आउटपुट कर सकें। आप हमारे ट्यूटोरियल में यह भी सीख सकते हैं कि pandas का उपयोग करके CSV फ़ाइलों से डेटा कैसे इंपोर्ट और एक्सपोर्ट करें। 

यदि, हालाँकि, आप Pandas में IO टूल्स पर अधिक जानकारी चाहते हैं, तो pandas की DataFrames to Excel डॉक्यूमेंटेशन देखें।