Polars read_csv(): Python में CSV डेटा तेज़ी से लोड करें

यदि आप मेरी तरह नियमित रूप से Python में डेटा विश्लेषण करते हैं, तो जल्द ही यह महसूस होता है कि CSV फ़ाइलें पढ़ना सबसे आम कामों में से एक है। लेकिन जैसे-जैसे आपके डेटासेट बड़े होते जाते हैं, यह तरीका धीमा या मेमोरी-गहन हो सकता है।

Polars Python के लिए एक तेज़, आधुनिक DataFrame लाइब्रेरी है, जिसे Pandas के उच्च-प्रदर्शन विकल्प के रूप में बनाया गया है। यह गति और कम मेमोरी उपयोग पर केंद्रित होने के कारण पारंपरिक टूल्स के मुकाबले बड़े डेटासेट को कहीं अधिक सुचारू रूप से संभाल सकती है।

Polars का pl.read_csv() कोर फ़ंक्शन CSV फ़ाइलों को DataFrame में लोड करने का सरल समाधान देता है, जिसमें पार्सिंग, डेटा टाइप्स और मेमोरी उपयोग को नियंत्रित करने के लिए बिल्ट-इन विकल्प होते हैं।

इस गाइड में, मैं आपको दिखाऊंगा कि Polars के  pl.read_csv() फ़ंक्शन का उपयोग करके CSV फ़ाइलें कैसे पढ़ें, पार्सिंग को कैसे नियंत्रित करें, और बड़े डेटासेट कैसे संभालें। यदि आप अभी शुरुआत कर रहे हैं, तो हमारा Introduction to Polars कोर्स देखें ताकि Polars के साथ डेटा में बदलाव करना और इनसाइट्स निकालना सीख सकें।

pl.read_csv() का बुनियादी उपयोग

आगे बढ़ने से पहले, अपना वातावरण सेट करने के लिए हमारा Python Polars ट्यूटोरियल देखें। 

अब देखें कि pl.read_csv() फ़ंक्शन कैसे काम करता है: 

# import the module
import polars as pl

# Load CSV into a Polars DataFrame
fuel_data = pl.read_csv("Fuel_Consumption_2000-2022.csv")  

# Preview first few rows
print(fuel_data.head())  

ऊपर दिए उदाहरण में, Polars फ़ाइल पढ़कर उसे DataFrame में लोड करता है। यह फ़ंक्शन Polars DataFrame लौटाता है, जो एक सारणीबद्ध डेटा संरचना है—pandas में मिलने वाले स्ट्रक्चर के समान।

डिफ़ॉल्ट रूप से, pl.read_csv():

• मानता है कि पहली पंक्ति में कॉलम नाम होते हैं (has_header=True)

• कॉलम के डेटा टाइप अपने-आप पता करता है

• विभाजक के रूप में कॉमा (,) का उपयोग करता है

• पूरी फ़ाइल को मेमोरी में पढ़ता है

pl.read_csv() में सामान्य पैरामीटर

अब जब आपने समझ लिया है कि pl.read_csv() डेटा कैसे लोड करता है, तो देखें कि आप नीचे दिए पैरामीटर का उपयोग करके Polars को अपना डेटा कैसे पार्स करना चाहिए, यह तय कर सकते हैं।

फ़ाइल पाथ और स्रोत

Polars आपको विभिन्न स्रोतों से डेटा लोड करने देता है। आप लोकल स्ट्रिंग पाथ, Pathlib ऑब्जेक्ट, या URL भी पास कर सकते हैं। उदाहरण के तौर पर, नीचे दिया कोड वेब से एक बड़ा CSV पढ़ता है जिसमें विभिन्न वर्षों में अलग-अलग देशों का GDP है।

# Reading from a URL
url = "https://raw.githubusercontent.com/datasets/gdp/master/data/gdp.csv"
gdp_data = pl.read_csv(url)

डिलिमिटर और सेपरेटर

सभी CSV फ़ाइलें कॉमा का उपयोग नहीं करतीं। आप separator आर्ग्युमेंट का उपयोग टैब, सेमिकॉलन, पाइप या अन्य अक्षरों के लिए कर सकते हैं। नीचे का उदाहरण दिखाता है कि फ़ाइलें पढ़ते समय सेपरेटर कैसे निर्दिष्ट करें।

# Reading a Semicolon-separated file
sales_data = pl.read_csv("2024_sales.csv", separator=";")

# Reading a Tab-separated file (TSV)
orders_data = pl.read_csv("all_orders.tsv", separator="\t")

हेडर हैंडलिंग

जैसा कि हमने देखा, Polars मानता है कि डेटा की पहली पंक्ति में कॉलम नाम होते हैं। यदि आपकी फ़ाइल में हेडर पंक्ति नहीं है, तो नीचे दिखाए अनुसार has_header=False पैरामीटर का उपयोग करें। Polars अपने-आप column_1, column_2, column_3 आदि जैसे कॉलम नाम असाइन कर देगा।

# Load file without a header
orders_data = pl.read_csv("all_orders.csv", has_header=False)

आप विशिष्ट कॉलम नाम देकर कॉलम का नाम भी बदल सकते हैं। उदाहरण के लिए:

# Providing specific column names
sales_data = pl.read_csv("sales_April.csv", new_columns=[
    "OrderDate", "OrderNumber", "ProductKey", "SalespersonKey", "Salesperson"])

एन्कोडिंग

अलग-अलग CSV फ़ाइलें अलग-अलग टेक्स्ट एन्कोडिंग का उपयोग कर सकती हैं। यदि आपको अजीब कैरेक्टर या त्रुटियाँ दिखें, तो एन्कोडिंग निर्दिष्ट करें:

# Load CSV into a Polars DataFrame
fuel_data = pl.read_csv("Fuel_Consumption_2000-2022.csv", encoding="utf8")  

अन्य आम एन्कोडिंग विकल्पों में ”latin1” और ”utf8-lossy” शामिल हैं, जो अमान्य कैरेक्टर को उपयुक्त रूप से संभालते हैं।

Polars में CSV पढ़ते समय कॉलम कैसे चुनें

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

# Load only specific columns
fuel_data = pl.read_csv("Fuel_Consumption_2000-2022.csv",
    columns=["YEAR", "MAKE", "MODEL"]
)

फ़ाइल लोड करते समय आवश्यक कॉलम चुनने से अनावश्यक डेटा लोड न होने के कारण मेमोरी उपयोग घटता है। यह तरीका फ़ाइल पढ़ने को तेज़ करता है और समूचे पाइपलाइन के प्रदर्शन में सुधार करता है।

Polars CSV में डेटा टाइप (स्कीमा) कैसे संभालें

Polars एक स्ट्रॉन्ग-टाइप्ड लाइब्रेरी है, यानी हर कॉलम का डेटा टाइप सुसंगत होना चाहिए—जैसे सभी इंटीजर या सभी स्ट्रिंग।

स्वचालित टाइप अनुमान

डिफ़ॉल्ट रूप से, Polars आपका डेटा जाँचता है और अपने-आप कॉलम टाइप तय करता है। यह तरीका अधिकांश मामलों में ठीक काम करता है, लेकिन कभी-कभी कॉलम की गलत व्याख्या कर सकता है—जैसे IDs को स्ट्रिंग की बजाय इंटीजर मान लेना।

स्कीमा मैन्युअली निर्दिष्ट करना

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

अधिकांश मामलों में, विशेष कॉलम के डेटा टाइप बताने के लिए schema_overrides का उपयोग करें और बाकी कॉलम Polars को इन्फर करने दें।

import polars as pl

# Manually overriding specific data types
empl_data = pl.read_csv(
    "all_employees.csv",
    schema_overrides={
        "id": pl.Int64,
        "name": pl.String,
        "age": pl.Int64,
        "salary": pl.Float64
    }
)

या पूरे DataFrame की संरचना परिभाषित करने के लिए schema का उपयोग करें।

# Manually define the full schema
empl_data = pl.read_csv(
    "all_employees.csv",
    schema={
        "id": pl.Int64,
        "name": pl.String,
        "age": pl.Int64,
        "salary": pl.Float64
    }
)

Polars CSV में मिसिंग वैल्यू कैसे संभालें

डिफ़ॉल्ट रूप से, Polars इन मिसिंग वैल्यू को अपने-आप पहचानकर उन्हें null के रूप में दर्शाता है। कभी-कभी ये मिसिंग वैल्यू विशेष स्ट्रिंग्स से दर्शाई जाती हैं, जैसे ”NA”, ”N/A”, या ”missing”। आप null_values का उपयोग करके इन्हें null मानने के लिए परिभाषित कर सकते हैं। 

# Treating "N/A" and "EMPTY" as nulls
survey_data = pl.read_csv(
    "survey_results.csv",
    null_values=["N/A", "EMPTY", "null"]
)

मिसिंग वैल्यू सही तरह से हैंडल करने पर, आप सुसंगत डेटा टाइप सुनिश्चित करते हैं और गलत गणनाओं से बचते हैं, जिससे विश्लेषण और मॉडलिंग के दौरान त्रुटियाँ कम होती हैं।

Polars में बड़ी CSV फ़ाइलें पढ़ना

जब आप ऐसे बड़े डेटासेट के साथ काम करते हैं जो आपकी उपलब्ध RAM से अधिक हैं, तो Polars वास्तव में चमकता है—यह पूरी फ़ाइल एक बार में लोड किए बिना डेटा प्रोसेस करता है।

scan_csv() के साथ लेज़ी लोडिंग

read_csv() की तरह डेटा तुरंत मेमोरी में लोड करने के बजाय, Polars एक लेज़ी विकल्प scan_csv() देता है, जो एक ऑप्टिमाइज़्ड क्वेरी प्लान बनाता है और केवल आवश्यक ऑपरेशन ही निष्पादित करता है।

नीचे के उदाहरण में, pl.scan_csv CSV को बिना लोड किए स्कैन करता है, एक क्वेरी बनाता है जो केवल “YEAR”, “MAKE”, और “MODEL” कॉलम लेती है जहाँ कार ब्रांड “ACURA” है, और फिर उस क्वेरी को निष्पादित करता है। इससे पूरी फ़ाइल की बजाय केवल फ़िल्टर्ड हिस्सा ही मेमोरी में लोड होता है।

# Lazily reference the file (no data loaded yet)
fuel_consumption = pl.scan_csv("Fuel_Consumption_2000-2022.csv")  

fuel_consumption_filtered = fuel_consumption.select(
    ["YEAR", "MAKE", "MODEL"]).filter(pl.col("MAKE") == "ACURA")

# Execute the query and load only the required data
fuel_consumption_acura = fuel_consumption_filtered.collect()  

मैं सुझाव दूंगा कि आप scan_csv() का उपयोग करें जब:

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

स्ट्रीमिंग और मेमोरी दक्षता

Polars डेटा को हिस्सों में स्ट्रीमिंग प्रोसेस भी करने देता है, जिससे फ़ाइल आकार चाहे जो हो, पीक मेमोरी स्थिर रहती है।

बड़ी CSV फ़ाइलों के लिए, लेज़ी क्वेरी बनाने के लिए scan_csv() से शुरू करें। scan_csv() कॉल होने पर फ़ाइल पूरी तरह लोड नहीं होती।

# Read data in chunks
fuel_consumption = pl.scan_csv("Fuel_Consumption_2000-2022.csv",
 low_memory=True)

चूँकि ऊपर की विधि अभी भी read_csv का उपयोग करती है, सबसे अच्छा तरीका लेज़ी एक्ज़िक्यूशन को स्ट्रीमिंग के साथ जोड़ना है। 

नीचे के उदाहरण में, Polars पाइपलाइन में फ़ाइल को बैच के रूप में, पंक्ति-दर-पंक्ति प्रोसेस करता है, और किसी भी समय केवल फ़िल्टर की गई पंक्तियाँ (“CYLINDERS” > 3 जहाँ हों) ही मेमोरी में रखता है। 

# Lazily reference the file (no data loaded yet)
fuel_consumption = pl.scan_csv("Fuel_Consumption_2000-2022.csv")  

result = fuel_consumption.filter(pl.col("CYLINDERS") > 3)

# Stream execution instead of loading everything at once
fuel_consumption_high = result.collect(engine="streaming")

Pandas के मुकाबले प्रदर्शन लाभ

pandas की तुलना में, जैसा कि हम अगले सेक्शन में देखेंगे, Polars अक्सर CSV पढ़ने और प्रोसेस करने में बेहतर प्रदर्शन देता है।

Polars read_csv बनाम Pandas read_csv

नीचे की तालिका Python में CSV पढ़ते समय Polars और Pandas के बीच अंतर का सार प्रस्तुत करती है।

मैं सुझाव दूंगा कि आप हमारे लेख में Pandas बनाम Polars के अंतर के बारे में पढ़ें, ताकि यह तय कर सकें कि आपकी एनालिटिक्स ज़रूरतों के लिए कौन-सा टूल बेहतर है।

विभिन्न स्रोतों से CSV पढ़ना

जैसा कि हमने पहले देखा, आप विभिन्न स्रोतों से CSV फ़ाइल पढ़ने के लिए Polars का उपयोग कर सकते हैं। ऊपर के उदाहरणों में, मैंने लोकल फ़ाइलों और URLs से CSV पढ़ना दिखाया है।

इसके अलावा, Polars संपीड़ित CSV फ़ाइलों को अपने-आप संभाल सकता है। उदाहरण के लिए, नीचे दिया कोड .gzip फ़ाइल से डेटा पढ़ता है।

# Read gzip-compressed CSV
census_data = pl.read_csv("2018_census.csv.gz")

सामान्य त्रुटियाँ और ट्रबलशूटिंग

Polars जैसे हाई-परफॉर्मेंस इंजन के साथ भी, खासकर CSV फ़ाइल पढ़ते समय, आपको कुछ समस्याएँ मिल सकती हैं। नीचे कुछ सामान्य समस्याएँ हैं जिनका मैंने सामना किया है और उन्हें कैसे ठीक करें।

• एन्कोडिंग त्रुटियाँ: आपको UnicodeDecodeError जैसी त्रुटि दिख सकती है, जिसका मतलब है कि फ़ाइल UTF-8 एन्कोडिंग का उपयोग नहीं कर रही—यह समस्या पुराने फ़ाइलों या Excel के कुछ संस्करणों से एक्सपोर्ट किए गए CSV में आम है। इसे ठीक करने के लिए उचित एन्कोडिंग सेट करें, या यदि फ़ाइल में असंगत/टूटे कैरेक्टर हैं तो “utf8-lossy” का उपयोग करें।

• डिलिमिटर से जुड़ी समस्याएँ: यदि आपका DataFrame लोड तो हो जाता है, लेकिन सारा डेटा एक ही कॉलम में ठूँस गया है, तो Polars सेपरेटर को पहचान नहीं पाया। इसे हल करने के लिए separator आर्ग्युमेंट से सही डिलिमिटर स्पष्ट रूप से सेट करें—जैसे सेमिकॉलन (;), टैब (\t) या पाइप (|).

• गलत डेटा टाइप: कभी-कभी Polars कॉलम टाइप गलत इन्फर कर सकता है—जैसे न्यूमेरिक IDs को स्ट्रिंग पढ़ना या पार्सिंग त्रुटियाँ आना। ऐसे में, आप विशेष कॉलम के लिए डेटा टाइप बताने हेतु schema_overrides का उपयोग कर सकते हैं। यदि आप हर कॉलम के टाइप परिभाषित करना चाहते हैं, तो schema का उपयोग करें। आप infer_schema_length भी बढ़ा सकते हैं, ताकि Polars स्कीमा इन्फर करने से पहले अधिक पंक्तियाँ जाँचे।

• बड़ी फ़ाइलों में मेमोरी समस्याएँ: यदि आपका Python प्रोसेस बड़ी फ़ाइल लोड करते समय क्रैश हो जाता है, तो इसका मतलब है कि आपकी RAM खत्म हो गई। इसे ठीक करने के लिए मेमोरी उपयोग घटाने और प्रदर्शन सुधारने हेतु read_csv() से scan_csv() (लेज़ी लोडिंग) पर स्विच करें। आप डेटासेट के कम कॉलम भी लोड कर सकते हैं या डेटा को हिस्सों में लोड करने के लिए स्ट्रीम एक्ज़िक्यूशन का उपयोग करें।

निष्कर्ष

Polars में read_csv() फ़ंक्शन उपयोग में सरल है लेकिन वास्तविक दुनिया के कामों के लिए पर्याप्त शक्तिशाली है। मेरी राय में, बढ़ते डेटासेट के साथ काम करते समय Polars को स्पष्ट बढ़त मिलती है।

अगले कदम के रूप में, इसके विभिन्न उपयोगों के बारे में जानने के लिए हमारा ब्लॉग Polars GPU इंजन देखें। यदि आप प्रैक्टिकल करना चाहते हैं, तो हमारा Super Bowl Analytics with Polars कोड-अलॉन्ग देखें—वास्तविक दुनिया के विश्लेषणात्मक प्रश्न हल करने, गणनाएँ लगाने और स्पोर्ट्स एनालिटिक्स की समस्याओं पर बेसिक ML तकनीकें लागू करने के लिए।