Pandas DataFrame को CSV में कैसे सहेजें

यदि आप कोई DataFrame बनाते हैं या किसी मौजूदा DataFrame में बदलाव करते हैं, तो आप उसे निर्यात करना चाहेंगे ताकि अन्य लोग उस पर काम कर सकें, या आप उसे आगे के काम के लिए सहेज सकें। उदाहरण के लिए, आपको मशीन लर्निंग प्रोजेक्ट से एक prediction अपने परीक्षक को जमा करना पड़ सकता है या संशोधित डेटासेट किसी सहकर्मी को भेजना पड़ सकता है।

Python में, आप Pandas के .to_csv() मेथड का उपयोग करके किसी DataFrame को CSV फ़ाइल के रूप में निर्यात कर सकते हैं।

इस लेख में, मैं आपको इस प्रक्रिया के मुख्य चरण बताऊँगा और इस मेथड के पैरामीटर्स समझाऊँगा।

यदि आप Pandas के बारे में और सीखना चाहते हैं, तो इस कोर्स पर नज़र डालें Data Manipulation with Pandas।

मैं जल्दबाज़ी में रहने वालों के लिए एक त्वरित उत्तर से शुरू करूँगा, उसके बाद विवरण में जाऊँगा।

संक्षिप्त उत्तर: Pandas DataFrame को CSV में कैसे सहेजें

Pandas DataFrame को CSV के रूप में सहेजने के लिए DataFrame.to_csv() मेथड का उपयोग करें: 

df.to_csv('your_file_name.csv', index=False)संचालित द्वारा

अपने फ़ाइल के वांछित नाम और पथ के साथ 'your_file_name.csv' को बदलें। index=False आर्ग्युमेंट Pandas को आपके CSV में एक इंडेक्स कॉलम जोड़ने से रोकता है।

Pandas DataFrame बनाना

अब, लंबा उत्तर देखते हैं। शून्य से DataFrame बनाने के बजाय, मैं एक डेटासेट इम्पोर्ट करूँगा, उसे संशोधित करूँगा, और परिणामस्वरूप बने DataFrame को CSV फ़ॉर्मेट में सहेजूँगा। पहला चरण आवश्यक लाइब्रेरियाँ इम्पोर्ट करना है:

import pandas as pd
import seaborn as sns
from sklearn.preprocessing import MinMaxScalerसंचालित द्वारा

इसके बाद, हम एक seaborn डेटासेट इम्पोर्ट कर सकते हैं। इम्पोर्ट किया गया डेटासेट पहले से ही एक Pandas DataFrame है, इसलिए हमें इसे ट्रांसफॉर्म करने की आवश्यकता नहीं है।

# We’ll import the 'titanic' dataset from seaborn
df = sns.load_dataset('titanic')
print(df.head())संचालित द्वारा

survived  pclass     sex   age  sibsp  parch     fare embarked  class  
0         0       3    male  22.0      1      0   7.2500        S  Third   
1         1       1  female  38.0      1      0  71.2833        C  First   
2         1       3  female  26.0      0      0   7.9250        S  Third   
3         1       1  female  35.0      1      0  53.1000        S  First   
4         0       3    male  35.0      0      0   8.0500        S  Third 
    who  adult_male deck  embark_town alive  alone  
0    man        True  NaN  Southampton    no  False  
1  woman       False    C    Cherbourg   yes  False  
2  woman       False  NaN  Southampton   yes   True  
3  woman       False    C  Southampton   yes  False  
4    man        True  NaN  Southampton    no   True  संचालित द्वारा

Pandas DataFrame संशोधित करना

अब, एक नया DataFrame प्राप्त करने के लिए कुछ प्रोसेसिंग करते हैं। चूँकि मेरा उद्देश्य Pandas के .to_csv() मेथड को समझना है, इसलिए मैं केवल संख्यात्मक वेरिएबल्स पर min-max normalization करूँगा।

scaler = MinMaxScaler()
# Choose the columns that have integer or float data-types                                           
numerical columns - df.select_dtypes(include=['float64','int64']).columns
new_df = df.copy()
# The min-max scaler will represent all numbers on a 0-to-1 scale
new_df[numerical_columns] = scaler.fit_transform(df[numerical_columns])
print(new_df.head())संचालित द्वारा

survived  pclass     sex       age  sibsp  parch      fare embarked    
0       0.0     1.0    male  0.271174  0.125    0.0  0.014151        S  
1       1.0     0.0  female  0.472229  0.125    0.0  0.139136        C  
2       1.0     1.0  female  0.321438  0.000    0.0  0.015469        S  
3       1.0     0.0  female  0.434531  0.125    0.0  0.103644        S  
4       0.0     1.0    male  0.434531  0.000    0.0  0.015713        S  
class   who  adult_male deck  embark_town alive  alone  
Third   man        True  NaN  Southampton    no  False  
First   woman      False   C    Cherbourg   yes  False  
Third   woman      False NaN  Southampton   yes   True  
First   woman      False   C  Southampton   yes  False  
Third   man        True  NaN  Southampton    no   True  संचालित द्वारा

Pandas DataFrame को CSV के रूप में सहेजना

हम संशोधित DataFrame को CSV फ़ाइल के रूप में सहेजने के लिए DataFrame.to_csv() मेथड का उपयोग करेंगे।

new_df.to_csv('new_titanic.csv') संचालित द्वारा

यह CSV फ़ाइल को वर्तमान डायरेक्टरी में सहेज देगा। यदि आपको ताज़ा करने की ज़रूरत है, तो यह ट्यूटोरियल पढ़ें Python में current directory कैसे प्राप्त करें।

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

DataFrame.to_csv() के पैरामीटर्स समझाए गए

यहाँ वही .to_csv() मेथड सभी पैरामीटर्स के साथ सूचीबद्ध है:

new_df.to_csv(
    path_or_buf='new_titanic.csv',
    sep=',',
    na_rep='',
    float_format=None,
    columns=[],
    header=True,
    index=True,
    index_label=None,
    mode='w',
    encoding='utf-8',
    quoting=csv.QUOTE_MINIMAL,
    lineterminator=os.linesep,
    storage_options={},
    compression='infer',
    quotechar='',
    chunksize=None,
    date_format=None,
    doublequote=True,
    escapechar=None,
    decimal='.',
    errors='strict'
)संचालित द्वारा

इनमें से कुछ पैरामीटर्स वैकल्पिक हैं, जैसे columns, encoding, quoting, lineterminator और storage_options, इसलिए मैंने इनके लिए केवल मान सेट किए हैं, ज़रूरी नहीं कि ये डिफ़ॉल्ट मान हों।

पहला पैरामीटर या तो एक स्ट्रिंग हो सकता है, जो फ़ाइल का नाम होगा, या एक फ़ाइल ऑब्जेक्ट। इस उदाहरण को देखें:

with open('new_titanic.csv',  'w', encoding = 'utf=8') as file:
     new_df.to_csv(file)संचालित द्वारा

सेपरेटर और missing values

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

उदाहरण के लिए, यदि आपके पास ‘Hello, world’ जैसा एक datapoint है, तो यदि आप कॉमा सेपरेटर का उपयोग करना चाहते हैं, तो आपको उसे एक ही datapoint बनाए रखने के लिए क्वोटेशन भी लगाने होंगे। इसके बजाय टैब या सेमिकोलोन सेपरेटर का उपयोग करना बेहतर विकल्प हो सकता है क्योंकि यह कॉमा और क्वोटेशन मार्क्स की तुलना में कम मेमोरी ले सकता है।

new_df.to_csv('new_titanic.csv', sep = '\t')
new_df_tab = pd.read_csv('new_titanic.csv')संचालित द्वारा

0\t0\t3\tmale\t22.0\t1\t0\t7.25\tS\tThird\tman...                                                                 
1\t1\t1\tfemale\t38.0\t1\t0\t71.2833\tC\tFirst...                                                                 
2\t1\t3\tfemale\t26.0\t0\t0\t7.925\tS\tThird\t...                                                                 
3\t1\t1\tfemale\t35.0\t1\t0\t53.1\tS\tFirst\tw...                                                                 
4\t0\t3\tmale\t35.0\t0\t0\t8.05\tS\tThird\tman... संचालित द्वारा

तीसरा पैरामीटर, na_rep, missing values के निरूपण से संबंधित है। सामान्य विकल्प होंगे सेल को खाली छोड़ना या ‘NaN’ या ‘Na’ डालना, लेकिन आप अपनी मनचाही स्ट्रिंग भी डाल सकते हैं। मैं निम्नलिखित उदाहरण में हर missing value के लिए ‘Datacamp’ डालूँगा।

new_df.to_csv('new_titanic.csv', na_rep='Datacamp')
new_df_datacamp = pd.read_csv('new_titanic.csv') 
new_df_datacamp = pd.DataFrame(new_df_datacamp) 
#find the missing values
missing_values = new_df_datacamp.isnull().sum()
print(missing_values)संचालित द्वारा

survived         0
pclass           0
sex              0
age            177
sibsp            0
parch            0
fare             0
embarked         2
class            0
who              0
adult_male       0
deck           688
embark_town      2
alive            0
alone            0संचालित द्वारा

कॉलम्स और इंडेक्स को संभालना

आइए देखें कि age कॉलम के लिए missing values कैसे दर्शाए गए हैं:

print(new_df_datacamp['age'][:10])संचालित द्वारा

     0.2711736617240512
     0.4722292033174164
    0.32143754712239253
     0.4345312892686604
     0.4345312892686604
               Datacamp
     0.6732847449107816
    0.01985423473234481
    0.33400351847197784
    0.17064589092736868संचालित द्वारा

यदि आप कम दशमलव स्थान चाहते हैं, तो float_format पैरामीटर का उपयोग कर दशमलव की संख्या निर्दिष्ट करें। यहाँ, हम केवल तीन का उपयोग करेंगे।

new_df.to_csv('new_titanic.csv', na_rep='Datacamp', float_format='%.3f')
new_df_datacamp = pd.read_csv('new_titanic.csv')
new_df_datacamp = pd.DataFrame(new_df_datacamp)
print(new_df_datacamp['age'][:10])संचालित द्वारा

0.271
0.472
0.321
0.435
0.435
Datacamp
0.673
0.020
0.334
0.171संचालित द्वारा

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

आप header पैरामीटर का उपयोग कर यह तय भी कर सकते हैं कि कॉलम नाम रखें या नहीं, और इसे True या False पर सेट कर सकते हैं (या आप कॉलम्स के लिए नाम स्वयं सेट कर सकते हैं)।

columns पैरामीटर आपको यह चुनने देता है कि कौन से कॉलम रखने हैं। index_label पैरामीटर आपको इंडेक्स कॉलम के लिए एक नाम सेट करने देता है या यदि आपके पास एक से अधिक इंडेक्स हैं तो नामों की सूची।

new_df.to_csv(
    'new_titanic.csv', 
    index=True, 
    header=True, 
    columns=['age', 'alive'], 
    index_label='Index'
)
new_df = pd.read_csv('new_titanic.csv')
new_df = pd.DataFrame(new_df)
print(new_df.head())संचालित द्वारा

  Index       age alive
      0  0.271174    no
      1  0.472229   yes
      2  0.321438   yes
      3  0.434531   yes
      4  0.434531    noसंचालित द्वारा

फ़ाइल ओपनिंग, एन्कोडिंग, और कम्प्रेशन

mode पैरामीटर आपको यह तय करने देता है कि जब आपके पास उसी नाम की CSV फ़ाइल पहले से मौजूद हो तो क्या करना है। यदि आप पैरामीटर को ‘w’ पर सेट करते हैं और new_titanic.csv फ़ाइल पहले से मौजूद है, तो आप जो फ़ाइल बनाएँगे वह पुरानी फ़ाइल को बदल देगी। यदि आप इसे ‘x’ पर सेट करते हैं, तो नई फ़ाइल तभी बनेगी जब उसी नाम की कोई फ़ाइल मौजूद न हो। अंत में, यदि आप पैरामीटर को ‘a’ पर सेट करते हैं, तो यह उसी नाम वाली पुरानी फ़ाइल में नई फ़ाइल को जोड़ देगा (शायद आप केवल कुछ पंक्तियाँ जोड़ना चाहते हों)।

Encoding पैरामीटर नई फ़ाइल का एन्कोडिंग सेट करता है। यदि आपके डेटा में विशेष अक्षर हैं, जैसे अन्य लिपियों के अक्षर, तो आप इसे ‘utf-8’ या किसी अन्य एन्कोडिंग पर सेट कर सकते हैं।

compression पैरामीटर नई फ़ाइल को संपीड़ित करने का तरीका सेट करता है। डिफ़ॉल्ट रूप से, यह ‘infer’ पर सेट है, जिसका अर्थ है कि यह निर्दिष्ट एक्सटेंशन के अनुसार फ़ाइल को कंप्रेस करता है, लेकिन आप अपनी मनचाही एक्सटेंशन भी निर्दिष्ट कर सकते हैं।

# Infer the compression
new_df.to_csv('new_titanic.csv.gz')
# Specify the compression explicitly
new_df.to_csv('new_data.csv.gz', compression='gzip')
# Specify the compression via a dictionary
new_df.to_csv(
    'new_data.zip', 
    compression={
        'method': 'zip', 
        'archive_name': 'data.csv'
    }
)संचालित द्वारा

Quoting का उपयोग कैसे करें

quoting पैरामीटर यह निर्धारित करता है कि किस प्रकार के डेटा को उद्धरण चिह्नों में रखना है। जैसा कि मैंने पहले कहा, जब आपके पास कॉमा सेपरेटर हो और सेल्स में भी कॉमा हों (जैसे टेक्स्ट), तो आपको तय करना होता है कि किन्हें उद्धरणों में रखा जाए।

# Default value, quotes only fields with special characters or separators like tabs and commas
new_df.to_csv('new_titanic.csv', quoting=csv.QUOTE_MINIMAL)
# Quotes all fields
new_df.to_csv('new_titanic.csv', quoting=csv.QUOTE_ALL)
# Quotes only fields with non-numeric values
new_df.to_csv('new_titanic.csv', quoting=csv.QUOTE_NONNUMERIC)
# No field is quoted
new_df.to_csv('new_titanic.csv', quoting=csv.QUOTE_NONE)संचालित द्वारा

Chunksize और दिनांक-समय डेटा

chunksize पैरामीटर निर्दिष्ट करता है कि एक बार में आपकी फ़ाइल का कितना भाग लिखा जाएगा। डिफ़ॉल्ट मान छोड़ने पर, सभी पंक्तियाँ एक साथ लिखी जाती हैं, लेकिन आप एक संख्या निर्दिष्ट कर सकते हैं, जो फ़ाइल बहुत बड़ी होने पर उपयोगी है।

date_format पैरामीटर datetime ऑब्जेक्ट्स के निरूपण को सेट करता है। आप इसे strftime फॉर्मेट का उपयोग करके निर्दिष्ट कर सकते हैं।

# Write DataFrame to CSV with dates formatted as 'MM/DD/YYYY'
new_df.to_csv('new_titanic.csv', date_format='%m/%d/%Y')
# You can set datetime objects up to seconds
new_df.to_csv('new_titanic.csv', date_format='%Y-%m-%d %H:%M:%S')संचालित द्वारा

निष्कर्ष

उम्मीद है, अब आप अपनी आवश्यकताओं के अनुसार अपने DataFrame को मनचाहे फ़ॉर्मेट में निर्यात करने के लिए तैयार होंगे!

मैं आपको सीखते रहने के लिए प्रोत्साहित करता हूँ—यहाँ कुछ संसाधन हैं जिन्हें आप आज़मा सकते हैं:

• Python में Data Science के लिए Pandas Cheat Sheet
• Writing Efficient Code with Pandas कोर्स
• Reshaping Data with Pandas कोर्स