📘 CodingMarble Learn

पांडास डेटाफ़्रेम: पूरी तालिका के साथ काम

डेटाफ़्रेम पांडास की द्वि-आयामी तालिका है, जिसमें लेबल वाली पंक्तियाँ (इंडेक्स) और लेबल वाले स्तंभ होते हैं। हर स्तंभ एक सीरीज़ है। इसे सीरीज़ की डिक्शनरी, डिक्शनरियों की सूची या CSV फ़ाइल से बनाते हैं। हम इसे दिखा सकते हैं, पंक्ति-दर-पंक्ति या स्तंभ-दर-स्तंभ घूम सकते हैं, पंक्तियाँ-स्तंभ जोड़, चुन, हटा और उनका नाम बदल सकते हैं, loc, iloc या शर्त से डेटा चुन सकते हैं, और CSV में वापस सहेज सकते हैं।

🎬 कदम-दर-कदम कहानी

  1. डेटाफ़्रेम एक तालिका है: कई सीरीज़ साथ-साथ खड़ी।
  2. इसे डिक्शनरियों की सूची से बनाएँ या CSV फ़ाइल से पढ़ें।
  3. इसे दिखाएँ, shape देखें, और पंक्ति या स्तंभ के हिसाब से घूमें।
  4. पंक्तियाँ और स्तंभ जोड़ें, हटाएँ और नाम बदलें।
  5. loc, iloc या शर्त से डेटा चुनें, फिर to_csv से सहेजें।
  6. आपकी बारी: कमांड चुनें और देखें कौन-से ख़ाने चमकते हैं।

टिप: 3D दृश्य को घुमाने के लिए खींचें। ज़ूम के लिए दो उंगलियाँ इस्तेमाल करें।

🤔 आम शंकाएँ और उनके जवाब

सीरीज़ और डेटाफ़्रेम में क्या अंतर है?

सीरीज़ इंडेक्स वाला एक स्तंभ है। डेटाफ़्रेम ऐसे कई स्तंभों की तालिका है, जिनका पंक्ति इंडेक्स एक ही है।

डिक्शनरियों की सूची से बनाने पर NaN क्यों दिखता है?

किसी पंक्ति की डिक्शनरी में वह कुंजी न हो जो दूसरों में है, तो वह ख़ाना ख़ाली रहता है और पांडास NaN लिखता है।

iterrows() कब इस्तेमाल करें?

जब हर पंक्ति पर अलग से काम करना हो, जैसे हर छात्र के लिए संदेश छापना। पूरे स्तंभ पर सरल गणित के लिए सीधे स्तंभ लें (df.Marks + 5); यह तेज़ है।

drop() में axis=1 का क्या अर्थ है?

axis=1 यानी स्तंभ (आड़े)। axis=0 यानी पंक्तियाँ (नीचे), और यही डिफ़ॉल्ट है।

मेरे drop() से तालिका क्यों नहीं बदली?

drop() नई तालिका लौटाता है। df = df.drop(...) लिखें या inplace=True जोड़ें।

and की जगह & क्यों लगाना पड़ता है?

स्तंभ पर शर्त कई True/False देती है। पायथन का and सिर्फ़ एक मान पर चलता है; & हर मान पर अलग चलता है। हर शर्त को कोष्ठक में रखें।

to_csv() में index=False क्या करता है?

यह पंक्ति लेबल (0, 1, 2 …) को फ़ाइल में अलग पहले स्तंभ के रूप में लिखने से रोकता है।

डेटाफ़्रेम क्या है?

डेटाफ़्रेम द्वि-आयामी लेबल वाली डेटा संरचना है। द्वि-आयामी यानी पंक्तियाँ और स्तंभ, जैसे तालिका। हर पंक्ति का एक लेबल (पंक्ति इंडेक्स) और हर स्तंभ का नाम (स्तंभ लेबल) होता है। हर स्तंभ एक सीरीज़ है, इसलिए अलग-अलग स्तंभों में अलग प्रकार (पाठ, संख्या) हो सकते हैं।

काम के गुण: df.shape (पंक्तियाँ, स्तंभ), df.index, df.columns, df.dtypes, df.size (ख़ानों की संख्या), df.values, df.T (पंक्ति-स्तंभ अदला-बदली), df.empty।

सीरीज़ की डिक्शनरी, डिक्शनरियों की सूची या CSV से डेटाफ़्रेम

सीरीज़ की डिक्शनरी से

name  = pd.Series(['Asha', 'Ravi', 'Mohan'])
marks = pd.Series([92, 75, 58])
df = pd.DataFrame({'Name': name, 'Marks': marks})

डिक्शनरी की कुंजियाँ स्तंभ-नाम बनती हैं। सीरीज़ के इंडेक्स अलग हों तो पांडास सब लेबल जोड़ता है और ख़ाली जगह NaN भरता है।

डिक्शनरियों की सूची से

rows = [{'Name': 'Asha', 'Marks': 92},
        {'Name': 'Ravi', 'Marks': 75, 'City': 'Pune'}]
df = pd.DataFrame(rows)     # हर डिक्शनरी एक पंक्ति; City न हो तो NaN

CSV फ़ाइल से

df = pd.read_csv('marks.csv')            # पहली लाइन = स्तंभ-नाम

सूचियों की डिक्शनरी या 2D सूची से भी columns= और index= देकर डेटाफ़्रेम बनता है।

डेटाफ़्रेम दिखाना

print(df)          # पूरी तालिका
df.head(3)         # पहली 3 पंक्तियाँ (डिफ़ॉल्ट 5)
df.tail(2)         # आख़िरी 2 पंक्तियाँ
df.shape           # (5, 3)
df.describe()      # संख्या वाले स्तंभों का count, mean, min, max …

पंक्तियों और स्तंभों पर इटरेशन

इटरेशन यानी लूप में एक-एक करके चीज़ों से गुज़रना।

for i, row in df.iterrows():      # पंक्ति-दर-पंक्ति
    print(i, row['Name'], row['Marks'])

for col, values in df.items():    # स्तंभ-दर-स्तंभ
    print(col, values.tolist())

iterrows() (पंक्ति लेबल, पंक्ति सीरीज़) देता है। items() (पुराना नाम iteritems()) (स्तंभ-नाम, स्तंभ सीरीज़) देता है।

पंक्तियाँ और स्तंभ जोड़ना, चुनना, हटाना, नाम बदलना

स्तंभ

df['Grade'] = ['A1', 'B1', 'C2', 'A2', 'C1']   # स्तंभ जोड़ें (या बदलें)
df['Marks']                    # एक स्तंभ चुनें (सीरीज़)
df[['Name', 'Marks']]          # कई स्तंभ (डेटाफ़्रेम)
df = df.drop('Grade', axis=1)  # स्तंभ हटाएँ
del df['City']                 # हटाने का दूसरा तरीका

पंक्तियाँ

df.loc[5] = ['Neha', 88, 'Pune']   # लेबल 5 वाली पंक्ति जोड़ें
df.loc[2]                          # पंक्ति चुनें
df = df.drop(2)                    # लेबल 2 वाली पंक्ति हटाएँ

नाम बदलना

df = df.rename(columns={'Marks': 'Score'})

drop() और rename() नया डेटाफ़्रेम लौटाते हैं; उसे वापस df में रखें या inplace=True लगाएँ।

लेबल इंडेक्सिंग और बूलियन इंडेक्सिंग

लेबल से: loc

df.loc[2, 'City']            # एक ख़ाना
df.loc[1:3, 'Name':'Marks']  # लेबल, आख़िरी शामिल

स्थान से: iloc

df.iloc[0:2]        # स्थान 0, 1 (आख़िरी शामिल नहीं)
df.iloc[0, 1]       # पंक्ति 0, स्तंभ 1

बूलियन इंडेक्सिंग

df[df.Marks > 80]
df[(df.City == 'Delhi') & (df.Marks > 90)]   # & = और, | = या, कोष्ठक लगाएँ

CSV फ़ाइल इम्पोर्ट और एक्सपोर्ट

CSV (कॉमा से अलग मान) फ़ाइल सादा पाठ है: हर लाइन एक पंक्ति, मान कॉमा से अलग। कोई भी स्प्रेडशीट इसे खोल सकती है।

df = pd.read_csv('marks.csv')                 # इम्पोर्ट
df.to_csv('result.csv', index=False)          # इंडेक्स के बिना एक्सपोर्ट

करके देखें: अपनी कक्षा की रिज़ल्ट शीट

किसी स्प्रेडशीट में 6 पंक्तियाँ (Name, Marks, City) लिखकर marks.csv नाम से सहेजें। पायथन में पढ़ें, df.shape छापें, Pass = df.Marks >= 33 स्तंभ जोड़ें, 80 से ऊपर वाले छाँटें और to_csv('toppers.csv', index=False) से सहेजें। हर लाइन से पहले उत्तर का अनुमान लिखें, फिर मिलाएँ। 3D के कदम 4 और 5 से तुलना करें।

मुख्य सूत्र और परिभाषाएँ

हल किए गए उदाहरण

1. तीन छात्रों का डेटाफ़्रेम सीरीज़ की डिक्शनरी से बनाकर shape छापिए।

n = pd.Series(['Asha','Ravi','Mohan']); m = pd.Series([92,75,58]); df = pd.DataFrame({'Name': n, 'Marks': m}); df.shape → (3, 2)।

2. rows = [{'a': 1, 'b': 2}, {'a': 5, 'c': 7}]। pd.DataFrame(rows) कैसा बनेगा?

स्तंभ a, b, c। पंक्ति 0: 1, 2, NaN। पंक्ति 1: 5, NaN, 7। जो कुंजी न हो वहाँ NaN।

3. 5 पंक्ति वाले df (Asha 92 Delhi, Ravi 75 Pune, Mohan 58 Agra, Zoya 81 Delhi, Kabir 66 Jaipur) में दिल्ली के छात्रों के नाम दिखाइए।

df.loc[df.City == 'Delhi', 'Name'] → Asha, Zoya।

4. Result स्तंभ जोड़िए: Marks ≥ 60 पर 'Pass', वरना 'Retest'।

df['Result'] = 'Pass'; df.loc[df.Marks < 60, 'Result'] = 'Retest'। सिर्फ़ Mohan (58) को Retest।

5. डिफ़ॉल्ट इंडेक्स 0–4 पर df.loc[1:3] और df.iloc[1:3] में क्या अंतर है?

loc लेबल लेता है और आख़िरी शामिल: पंक्तियाँ 1, 2, 3 (3 पंक्तियाँ)। iloc स्थान लेता है, आख़िरी छोड़ता है: 1, 2 (2 पंक्तियाँ)।

6. City स्तंभ हटाइए, Marks का नाम Score कीजिए और इंडेक्स के बिना 'final.csv' में सहेजिए।

df = df.drop('City', axis=1); df = df.rename(columns={'Marks': 'Score'}); df.to_csv('final.csv', index=False)।

7. iterrows() से हर छात्र का नाम 5 अतिरिक्त अंकों के साथ छापिए।

for i, row in df.iterrows(): print(row['Name'], row['Marks'] + 5) → Asha 97, Ravi 80, Mohan 63, Zoya 86, Kabir 71।

आम गलतियाँ

अभ्यास क्विज़

1. डिक्शनरियों की सूची से बने डेटाफ़्रेम में हर डिक्शनरी बनती है:
2. 6 पंक्ति और 4 स्तंभ वाले df का df.shape:
3. कौन तालिका पर पंक्ति-दर-पंक्ति लूप चलाता है?
4. 'City' स्तंभ हटाने के लिए:
5. डेटाफ़्रेम को CSV फ़ाइल में कौन सहेजता है?

अभ्यास: खुद जवाब दो

अपना जवाब लिखो या चुनो, फिर जाँचें दबाओ। अटको तो संकेत देखो; जवाब देने के बाद पूरा हल दिखेगा।

अक्सर पूछे जाने वाले प्रश्न

कक्षा 12 पांडास में डेटाफ़्रेम क्या है?

डेटाफ़्रेम पंक्ति और स्तंभ वाली द्वि-आयामी लेबल वाली तालिका है, जिसका हर स्तंभ एक सीरीज़ है।

loc और iloc में क्या अंतर है?

loc लेबल से चुनता है और स्लाइस का आख़िरी शामिल करता है; iloc पूर्णांक स्थान से चुनता है और आख़िरी छोड़ देता है।

पांडास में CSV इम्पोर्ट-एक्सपोर्ट कैसे करें?

इम्पोर्ट के लिए pd.read_csv('file.csv') और एक्सपोर्ट के लिए df.to_csv('file.csv', index=False)।

यह कहाँ पढ़ाया जाता है

सीबीएसई (भारत)कक्षा 12पांडास द्वारा डेटा प्रबंधन और डेटा दृश्यीकरण

पहले यह पढ़ें

आगे पढ़ें

इससे जुड़े पाठ

सभी सूचना विज्ञान अभ्यास पाठ