PySpark Read CSV: बड़े फ़ाइलों को कुशलतापूर्वक लोड करें और प्रोसेस करें

डेटा प्रोसेसिंग और एनालिटिक्स में CSV फाइलें एक अहम स्तंभ हैं। लगभग हर डेटा प्रोफेशनल—मिड-लेवल डेटा इंजीनियर और डेटा साइंटिस्ट से लेकर PySpark का उपयोग करने वाले डेवलपर तक—किसी न किसी बिंदु पर CSV फाइलों से काम करता है। लेकिन जैसे-जैसे डेटासेट मेगाबाइट से गीगाबाइट, और फिर टेराबाइट या उससे भी आगे बढ़ते हैं, Pandas या मानक Python लाइब्रेरी जैसे सरल, एकल टूल इस लोड को संभालने में संघर्ष करने लगते हैं। यहीं पर Apache Spark और PySpark वितरित कंप्यूटिंग वातावरण में बड़े पैमाने की CSV फाइलों को मैनेज करने के लिए महत्वपूर्ण हो जाते हैं।

यह लेख आपको PySpark के साथ बड़ी CSV फाइलें पढ़ते समय आवश्यक सभी जानकारियाँ सिखाएगा। 

सुनिश्चित करें कि आपने PySpark इंस्टॉल कर रखा है और आप बुनियादी बातों से परिचित हैं—इसके लिए हमारा Getting Started with PySpark ट्यूटोरियल देखें। 

PySpark में CSV पढ़ना क्या है?

PySpark उपयोगकर्ताओं को CSV फाइलों को वितरित DataFrames में पढ़ने की सुविधा देता है। PySpark में DataFrames, Pandas DataFrames से काफी मिलते-जुलते हैं और परिचित इंटरफ़ेस प्रदान करते हैं। हालांकि आंतरिक स्तर पर, PySpark DataFrames गणना और स्टोरेज को कई नोड्स में बाँट देते हैं, जिससे बहुत बड़े डेटासेट्स के लिए बेहतरीन प्रदर्शन मिलता है। 

बड़ी CSV फाइलों के लिए PySpark कई प्रभावशाली लाभ देता है, जैसे:

• वितरित डेटा लोडिंग,
• null मानों का मज़बूत हैंडलिंग,
• स्कीमा परिभाषित करने में लचीलापन, और
• कई या कंप्रेस्ड CSV फाइलों को मैनेज करने के आसान तरीके।

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

PySpark में CSV फाइलें पढ़ना उन विषयों में से एक है जिन्हें समझना PySpark इंटरव्यू में अच्छा करने के लिए ज़रूरी है। हमारा 2025 के लिए शीर्ष 36 PySpark इंटरव्यू प्रश्न और उत्तर बुनियादी अवधारणाओं से लेकर उन्नत तकनीकों और अनुकूलन रणनीतियों तक का व्यापक मार्गदर्शन देता है।  

PySpark में CSV फाइलें पढ़ने के मूल सिद्धांत

CSV डेटा पढ़ना अक्सर PySpark वर्कफ़्लो के शुरुआती और सबसे महत्वपूर्ण चरणों में से एक होता है—जो आगे होने वाले ट्रांसफॉर्मेशन, एक्सप्लोरेटरी एनालिसिस और मशीन लर्निंग कार्यों की नींव रखता है। इस चरण को सही करने से डेटा प्रोसेसिंग साफ-सुथरी होती है और डाउनस्ट्रीम प्रदर्शन बेहतर होता है।

अवधारणात्मक ढांचा

PySpark, Spark के वितरित मॉडल के भीतर CSV फाइलें पढ़ता है। किसी एक मशीन की मेमोरी में पूरा CSV डेटा पढ़ने के बजाय, Spark बड़े डेटा कार्यों को क्लस्टर के कई नोड्स में बाँट देता है। Spark का बिल्ट-इन Catalyst optimizer CSV इन्गेशन के दौरान आवश्यक क्रियाओं को कुशलतापूर्वक निष्पादित करके प्रदर्शन को और बेहतर करता है।

मुख्य रीड सिंटैक्स

CSV फाइलें पढ़ने का सरल तरीका Spark के बिल्ट-इन फ़ंक्शन्स का उपयोग करता है: 

spark.read.csv("file_path", header=True, inferSchema=True)संचालित द्वारा

या स्पष्ट रूप से:

spark.read.format("csv").option("header", "True").load("file_path")संचालित द्वारा

मुख्य पैरामीटर शामिल हैं:

• file_path - CSV फाइलों का लोकेशन।
• header - यदि True है तो CSV हेडर से कॉलम नाम सेट करता है।
• inferSchema - कॉलम के डेटा टाइप्स को स्वतः अनुमानित करता है।
• delimiter - कॉलम को अलग करने वाला कैरेक्टर; डिफ़ॉल्ट कॉमा है।

हमारा Learn PySpark From Scratch in 2025 ट्यूटोरियल PySpark की बुनियादी बातों और इसे कैसे सीखें, इस पर विस्तार से बताता है। 

CSV फाइलें पढ़ना: विकल्प और कॉन्फ़िगरेशन

PySpark व्यापक विकल्प प्रदान करता है जो CSV पढ़ने की प्रक्रिया पर सूक्ष्म नियंत्रण देते हैं।

हेडर और स्कीमा इन्फ़रेंस

header=True सेट करने से Spark पहली CSV लाइन को कॉलम नामों के रूप में उपयोग करता है।

inferSchema=True  Spark को आपका डेटा स्कैन करके कॉलम टाइप्स का स्वतः अनुमान लगाने देता है:

spark.read.csv("customers.csv", header=True, inferSchema=True)संचालित द्वारा

हालाँकि शुरुआती तौर पर स्कीमा इन्फ़रेंस सुविधाजनक और प्रभावी है, बड़े डेटासेट्स में प्रदर्शन घट सकता है क्योंकि Spark डेटा टाइप्स निर्धारित करने के लिए डेटा पर बार-बार पास लगाता है।

कस्टम स्कीमा स्पेसिफिकेशन 

अपना स्कीमा स्पष्ट रूप से परिभाषित करना, Spark के बार-बार डेटा स्कैन को समाप्त करके प्रदर्शन को काफी बढ़ा देता है। परिभाषित स्कीमा, कॉलम नामों और टाइप्स को पहले से ही संप्रेषित कर देता है।

यहाँ PySpark में कस्टम स्कीमा कैसे परिभाषित करें:

from pyspark.sql.types import StructType, StructField, StringType, IntegerType, DoubleType
schema = StructType([
    StructField("user_id", IntegerType(), True),
    StructField("name", StringType(), True),
    StructField("score", DoubleType(), True),
])
df = spark.read.csv("customers.csv", schema=schema, header=True)संचालित द्वारा

अब, CSV फाइलें पढ़ते समय PySpark में डिलीमीटर हैंडलिंग का अन्वेषण करते हैं। 

डिलीमीटर और विशेष कैरेक्टर्स को संभालना

कई CSV फाइलें कॉमा के अलावा पाइप या टैब जैसे डिलीमीटर का उपयोग करती हैं। PySpark आपको डिलीमीटर को स्पष्ट रूप से निर्दिष्ट करने देता है:

spark.read.csv("customers.csv", header=True, delimiter="|")संचालित द्वारा

इसके अतिरिक्त, विशेष कैरेक्टर परिदृश्यों को संभालने के लिए escape और quote कैरेक्टर भी कॉन्फ़िगर किए जा सकते हैं:

spark.read.csv("data.csv", header=True, escape='\"', quote='"')संचालित द्वारा

null और मिसिंग मानों का प्रबंधन

वास्तविक दुनिया के CSV डेटा में अक्सर असंगतियाँ या अधूरे रिकॉर्ड होते हैं। PySpark कस्टम प्लेसहोल्डर्स को null मानों में अनुवाद करके null को संभालना आसान बना देता है:

spark.read.csv("customers.csv", header=True, schema=schema, nullValue="NA")संचालित द्वारा

यह null मानों को स्पष्ट करता है, जिससे बाद में मैन्युअल डेटा सफाई की आवश्यकता काफी कम हो जाती है।

आइए null मानों से निपटने की अन्य रणनीतियाँ देखें। 

आप null मानों को फ़िल्टर करने का निर्णय ले सकते हैं: 

# Filter rows where Age is not null
df_filtered = df.filter(df["Age"].isNotNull())
df_filtered.show()संचालित द्वारा

यह DataFrame को केवल उन्हीं पंक्तियों तक सीमित करता है जहाँ Age कॉलम null नहीं है। आउटपुट कुछ इस प्रकार होगा:

+---+-----+---+------+
| ID| Name|Age|Salary|
+---+-----+---+------+
|  1| John| 25| 50000|
|  3|  Bob| 30|  NULL|
|  4|Carol| 28| 55000|
+---+-----+---+------+संचालित द्वारा

दूसरी रणनीति null मानों को भरने की है: 

# Replace null values in Age and Salary with default values
df_filled = df.na.fill({"Age": 0, "Salary": 0})
df_filled.show()संचालित द्वारा

आउटपुट इस तरह दिखेगा: 

+---+-----+---+------+
| ID| Name|Age|Salary|
+---+-----+---+------+
|  1| John| 25| 50000|
|  2|Alice|  0| 60000|
|  3|  Bob| 30|     0|
|  4|Carol| 28| 55000|
|  5|David|  0| 48000|
+---+-----+---+------+संचालित द्वारा

एकाधिक फाइलें और डायरेक्टरी पढ़ना

PySpark बड़े, मल्टी-फाइल डेटासेट्स को मैनेज करने में उत्कृष्ट है। किसी डायरेक्टरी से फाइलों को क्रम से मैन्युअल रूप से लोड और मर्ज करने के बजाय, PySpark तेज़ और कुशल बल्क लोडिंग के लिए वाइल्डकार्ड पैटर्न सपोर्ट करता है:

spark.read.csv("/data/sales/*.csv", header=True, schema=schema)संचालित द्वारा

यह एक ही सुव्यवस्थित ऑपरेशन में कई CSV फाइलों को प्रभावी ढंग से एक DataFrame में एकत्र कर देता है।

जब डेटा PySpark में लोड हो जाता है, तो अगले चरणों में रैंगलिंग, फीचर इंजीनियरिंग और मशीन लर्निंग मॉडल बनाना शामिल होता है। हमारा Feature Engineering with PySpark कोर्स इन अवधारणाओं को गहराई से कवर करता है। 

कुशल CSV रीडिंग के लिए अनुकूलन तकनीकें

बड़े पैमाने के CSV डेटा को संभालते समय, PySpark की अनुकूलन रणनीतियों का लाभ उठाना महत्वपूर्ण है।

पार्टिशनिंग रणनीतियाँ

पार्टिशनिंग, डेटा को क्लस्टर नोड्स में समान रूप से वितरित करके प्रदर्शन पर गहरा प्रभाव डालती है। Spark, डेटा इन्गेशन के दौरान पार्टिशन के आकार और संख्या पर स्पष्ट नियंत्रण देता है जिससे बाद के ऑपरेशंस तेज़ हो पाते हैं:

df = spark.read.csv("data.csv", header=True, schema=schema).repartition(20)संचालित द्वारा

​​.repartition(20) आपके Spark क्लस्टर में DataFrame को 20 पार्टिशनों में विभाजित करता है। चूँकि Spark डेटा को हिस्सों में प्रोसेस करता है, अधिक पार्टिशन होने से ये लाभ हो सकते हैं:

• समानांतरता में सुधार
• क्लस्टर में वर्कलोड का संतुलन
• ट्रांसफॉर्मेशन और राइट्स को तेज़ करना

यदि आप कई कोर वाले क्लस्टर पर चला रहे हैं, तो यह उनका पूरा उपयोग करने में मदद करता है। लेकिन अगर आप इसे ज़रूरत से ज़्यादा कर दें (जैसे, छोटे डेटासेट पर 1000 पार्टिशन), तो यह धीमा भी कर सकता है।

हमारे PySpark Cheat Sheet: Spark in Python के साथ repartition जैसी और Spark फ़ंक्शन्स खोजें। इसमें Python में Spark इनिशियलाइज़ करना, डेटा लोड करना, सॉर्टिंग और रीपार्टिशनिंग पर विस्तार से जानकारी है। 

कैशिंग और परसिस्टेंस

यदि आपके वर्कफ़्लो में इन्गेशन के बाद एक ही डेटासेट तक बार-बार पहुँच शामिल है, तो अपने DataFrame को मेमोरी या डिस्क पर कैश करना प्रदर्शन को काफी बढ़ा सकता है:

df.cache()संचालित द्वारा

हालाँकि, याद रखें कि कैशिंग के लिए पर्याप्त सिस्टम संसाधन चाहिए; हमेशा मेमोरी उपयोग और प्रदर्शन लाभ के बीच संतुलन बनाए रखें।

लेज़ी इवैल्यूएशन और एक्शन्स ट्रिगर करना

PySpark लेज़ी इवैल्यूएशन मॉडल पर निर्भर करता है: DataFrame ऑपरेशंस तुरंत निष्पादित होने के बजाय प्लान्स को ट्रांसफॉर्म करते हैं। वास्तविक फाइल पढ़ना तभी निष्पादित होता है जब उसकी ज़रूरत पड़ती है—जैसे show(), count(), या collect() जैसे कमांड से ट्रिगर होने पर:

# no reading yet
df = spark.read.csv("data.csv", header=True, schema=schema)   
# actual read triggered here
df.show(5)  संचालित द्वारा

उन्नत उपयोग के मामले और विचार

आइए कुछ जटिल परिदृश्यों का अन्वेषण करें जिनका सामना आपको CSV फाइलें पढ़ते समय हो सकता है: 

कंप्रेस्ड CSV फाइलें पढ़ना

Spark, gz या .bz2 जैसी कंप्रेस्ड CSV फाइलों को बिना अतिरिक्त कॉन्फ़िगरेशन के पारदर्शी रूप से कुशलतापूर्वक मैनेज करता है:

spark.read.csv("logs.csv.gz", header=True, schema=schema)संचालित द्वारा

खराब रिकॉर्ड्स को संभालना

CSV डेटासेट्स में खराब पंक्तियाँ हो सकती हैं। PySpark त्रुटियों या खराब रिकॉर्ड्स को सहजता से मैनेज करने के लिए कई विकल्प देता है:

• mode="PERMISSIVE" (डिफ़ॉल्ट): खराब पंक्तियों को null-भरे कॉलम्स के साथ शामिल करता है।
• mode="DROPMALFORMED: खराब रिकॉर्ड्स को चुपचाप छोड़ देता है। यह मोड CSV बिल्ट-इन फ़ंक्शन्स में असमर्थित है।
• mode="FAILFAST": किसी भी खराब रिकॉर्ड के मिलने पर अपवाद फेंकता है।

spark.read.csv("data.csv", header=True, schema=schema, mode="FAILFAST")संचालित द्वारा

लोकेल और एन्कोडिंग सेटिंग्स

कभी-कभी CSV डेटा गैर-मानक एन्कोडिंग का उपयोग करता है। PySpark, एन्कोडिंग पैरामीटर के माध्यम से अलग-अलग एन्कोडिंग को आसानी से संभालता है:

spark.read.csv("data_utf8.csv", header=True, encoding="UTF-8")संचालित द्वारा

समर्थित एन्कोडिंग में शामिल हैं, US-ASCII, ISO-8859-1, UTF-8, UTF-16BE, UTF-16LE, और UTF-16. 

सर्वोत्तम प्रथाएँ और आम गलतियाँ

Spark के साथ CSV फाइलें पढ़ते समय ध्यान रखने योग्य कुछ सर्वोत्तम प्रथाएँ:

• जहाँ भी डेटासेट संरचना ज्ञात हो, स्कीमा को स्पष्ट रूप से निर्दिष्ट करें।
• वर्कलोड को कुशलता से वितरित करने के लिए पार्टिशनिंग नियंत्रित करें।
• अक्सर एक्सेस होने वाले DataFrames के लिए रणनीतिक रूप से कैश करें।
• लेज़ी इवैल्यूएशन को ध्यान में रखते हुए, पढ़ने की एक्शन्स को जानबूझकर ट्रिगर करें।

इनसे बचें: 

• हेडर पंक्तियों वाले CSVs के लिए header=False सेट करना।
• बड़े या बार-बार एक्सेस होने वाले डेटासेट्स में सिर्फ inferSchema पर निर्भर रहना।
• महत्वपूर्ण डिलीमीटर या एन्कोडिंग सेटिंग्स को नज़रअंदाज़ करना।

निष्कर्ष

PySpark की शक्तिशाली CSV इन्गेशन क्षमताओं को सही ढंग से समझना और उपयोग करना, प्रभावी बिग डेटा प्रोसेसिंग के लिए आवश्यक है। स्पष्ट स्कीमा स्पेसिफिकेशन, कस्टम null फ़ॉर्मैट्स का हैंडलिंग, कुशल पार्टिशनिंग का उपयोग, और कंप्रेस्ड या मल्टी-फाइल परिदृश्यों का प्रबंधन—इन सबके साथ आपका वर्कफ़्लो सरल और उच्च प्रदर्शन वाला बनता है।

ध्यान रखें, जहाँ PySpark बड़े पैमाने के डेटा कार्यों के लिए अपार लाभ देता है, वहीं छोटे डेटासेट्स के लिए Pandas जैसे सरल टूल भी पर्याप्त हो सकते हैं। जब डेटा एकल मशीन की क्षमता से आगे निकल जाए तब PySpark का उपयोग करें, और हमेशा इसके वितरित कंप्यूटिंग लाभों पर विचार करें।

PySpark को और गहराई से जानने के लिए हमारे विस्तृत Spark कोर्सेज देखें, जिनमें शामिल हैं:

• Introduction to PySpark
• Foundations of PySpark 
• Big Data Fundamentals with PySpark
• Building Recommendation Engines with PySpark