परिचय

पायस्पार्क में विंडो फ़ंक्शंस के बारे में सीखना चुनौतीपूर्ण हो सकता है लेकिन प्रयास के लायक है। विंडो फ़ंक्शंस डेटा का विश्लेषण करने के लिए एक शक्तिशाली उपकरण है और आपको ऐसी अंतर्दृष्टि प्राप्त करने में मदद कर सकता है जो आपने अन्यथा नहीं देखी होगी। स्पार्क में विंडो फ़ंक्शंस का उपयोग कैसे करें यह समझकर; आप अपना ले सकते हैं डेटा विश्लेषण कौशल को अगले स्तर तक ले जाना और अधिक जानकारीपूर्ण निर्णय लेना। चाहे आप बड़े या छोटे के साथ काम कर रहे हों डेटासेट, स्पार्क में विंडो फ़ंक्शंस सीखने से आपको नए और रोमांचक तरीकों से डेटा में हेरफेर और विश्लेषण करने की अनुमति मिलेगी।

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

सीखने के मकसद

• विंडो फ़ंक्शंस की अवधारणा को समझें।
• डेटासेट का उपयोग करके विंडो फ़ंक्शंस के साथ कार्य करना।
• विंडो फ़ंक्शंस का उपयोग करके अंतर्दृष्टि प्राप्त करें।
• विंडो फ़ंक्शंस के साथ काम करने के लिए स्पार्क SQL और डेटाफ़्रेम एपीआई का उपयोग करें।

इस लेख के एक भाग के रूप में प्रकाशित किया गया था डेटा साइंस ब्लॉगथॉन।

विंडो फ़ंक्शंस क्या हैं?

विंडो फ़ंक्शंस एक दूसरे से संबंधित पंक्तियों के समूह के भीतर डेटा का विश्लेषण करने में मदद करते हैं। वे उपयोगकर्ताओं को कुछ विभाजन और ऑर्डरिंग मानदंडों के आधार पर एक दूसरे से जुड़े डेटाफ्रेम या डेटासेट की पंक्तियों पर जटिल परिवर्तन करने में सक्षम बनाते हैं।

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

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

SQL में विंडो फ़ंक्शंस

स्पार्क SQL तीन प्रकार के विंडो फ़ंक्शंस का समर्थन करता है:

• रैंकिंग कार्य:- ये फ़ंक्शन परिणाम सेट के विभाजन के भीतर प्रत्येक पंक्ति को एक रैंक प्रदान करते हैं। उदाहरण के लिए, ROW_NUMBER() फ़ंक्शन विभाजन के भीतर प्रत्येक पंक्ति को एक अद्वितीय अनुक्रमिक संख्या देता है।

• विश्लेषिकी कार्य:- ये फ़ंक्शन पंक्तियों की एक विंडो पर समग्र मानों की गणना करते हैं। उदाहरण के लिए, SUM() फ़ंक्शन पंक्तियों की एक विंडो पर एक कॉलम के योग की गणना करता है।
• मूल्य कार्य:- ये फ़ंक्शन उसी विभाजन में अन्य पंक्तियों के मानों के आधार पर, विभाजन में प्रत्येक पंक्ति के लिए एक विश्लेषणात्मक मान की गणना करते हैं। उदाहरण के लिए, LAG() फ़ंक्शन विभाजन में पिछली पंक्ति से एक कॉलम का मान लौटाता है।

डेटाफ़्रेम निर्माण

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

डेटाफ़्रेम में कर्मचारियों का विवरण है जैसे उनका नाम, पदनाम, कर्मचारी संख्या, नियुक्ति तिथि, वेतन आदि। कुल मिलाकर हमारे पास 8 कॉलम हैं जो इस प्रकार हैं:

• 'एम्पनो': इस कॉलम में कर्मचारी का नंबर होता है।
• 'नाम': इस कॉलम में कर्मचारियों के नाम हैं।
• 'नौकरी': इस कॉलम में कर्मचारियों की नौकरी के शीर्षक के बारे में जानकारी है।
• 'किराये की तारीख': यह कॉलम कर्मचारी की नियुक्ति की तारीख दिखाता है।
• 'सैल': इस कॉलम में वेतन विवरण शामिल है।
• 'कॉम': इस कॉलम में कर्मचारी कमीशन का विवरण, यदि कोई हो, है।
• 'डिप्टनो': कर्मचारी जिस विभाग से संबंधित है वह विभाग संख्या इस कॉलम में है।

# Create Sample Dataframe
employees = [
    (7369, "SMITH", "CLERK", "17-Dec-80", 800, 20, 10),
    (7499, "ALLEN", "SALESMAN", "20-Feb-81", 1600, 300, 30),
    (7521, "WARD", "SALESMAN", "22-Feb-81", 1250, 500, 30),
    (7566, "JONES", "MANAGER", "2-Apr-81", 2975, 0, 20),
    (7654, "MARTIN", "SALESMAN", "28-Sep-81", 1250, 1400, 30),
    (7698, "BLAKE", "MANAGER", "1-May-81", 2850, 0, 30),
    (7782, "CLARK", "MANAGER", "9-Jun-81", 2450, 0, 10),
    (7788, "SCOTT", "ANALYST", "19-Apr-87", 3000, 0, 20),
    (7629, "ALEX", "SALESMAN", "28-Sep-79", 1150, 1400, 30),
    (7839, "KING", "PRESIDENT", "17-Nov-81", 5000, 0, 10),
    (7844, "TURNER", "SALESMAN", "8-Sep-81", 1500, 0, 30),
    (7876, "ADAMS", "CLERK", "23-May-87", 1100, 0, 20)    
]

# create dataframe
emp_df = spark.createDataFrame(employees, 
           ["empno", "ename", "job", "hiredate", "sal", "comm", "deptno"])
emp_df.show()

# Output:
+-----+------+---------+---------+----+----+------+
|empno| ename|      job| hiredate| sal|comm|deptno|
+-----+------+---------+---------+----+----+------+
| 7369| SMITH|    CLERK|17-Dec-80| 800|  20|    10|
| 7499| ALLEN| SALESMAN|20-Feb-81|1600| 300|    30|
| 7521|  WARD| SALESMAN|22-Feb-81|1250| 500|    30|
| 7566| JONES|  MANAGER| 2-Apr-81|2975|   0|    20|
| 7654|MARTIN| SALESMAN|28-Sep-81|1250|1400|    30|
| 7698| BLAKE|  MANAGER| 1-May-81|2850|   0|    30|
| 7782| CLARK|  MANAGER| 9-Jun-81|2450|   0|    10|
| 7788| SCOTT|  ANALYST|19-Apr-87|3000|   0|    20|
| 7629|  ALEX| SALESMAN|28-Sep-79|1150|1400|    30|
| 7839|  KING|PRESIDENT|17-Nov-81|5000|   0|    10|
| 7844|TURNER| SALESMAN| 8-Sep-81|1500|   0|    30|
| 7876| ADAMS|    CLERK|23-May-87|1100|   0|    20|
+-----+------+---------+---------+----+----+------+

अब हम स्कीम की जाँच करेंगे:

# Checking the schema

emp_df.printSchema()

# Output:-
root
 |-- empno: long (nullable = true)
 |-- ename: string (nullable = true)
 |-- job: string (nullable = true)
 |-- hiredate: string (nullable = true)
 |-- sal: long (nullable = true)
 |-- comm: long (nullable = true)
 |-- deptno: long (nullable = true)

"emp" नाम से डेटाफ़्रेम 'emp_df' का एक अस्थायी दृश्य बनाएं। यह हमें स्पार्क एसक्यूएल में एसक्यूएल सिंटैक्स का उपयोग करके डेटाफ़्रेम को क्वेरी करने की अनुमति देता है जैसे कि यह एक तालिका थी। अस्थायी दृश्य केवल स्पार्क सत्र की अवधि के लिए मान्य है।

emp_df.createOrReplaceTempView("emp")

विंडो फ़ंक्शंस का उपयोग करके समस्या कथनों का समाधान करना

यहां हम विंडोज़ फ़ंक्शंस का उपयोग करके कई समस्या कथनों का समाधान करेंगे:

Q1. प्रत्येक विभाग में वेतन को रैंक करें।

# Using spark sql

rank_df = spark.sql(
        """SELECT empno, ename, job, deptno, sal, 
        RANK() OVER (PARTITION BY deptno ORDER BY sal DESC) AS rank FROM emp""")
rank_df.show()

# Using PySpark

windowSpec = Window.partitionBy(col('deptno')).orderBy(col('sal').desc())
            ranking_result_df = emp_df.select('empno', 'ename', 'job', 'deptno', 'sal', 
            F.rank().over(windowSpec).alias('rank'))
ranking_result_df.show()

# Output:-
+-----+------+---------+------+----+----+
|empno| ename|      job|deptno| sal|rank|
+-----+------+---------+------+----+----+
| 7839|  KING|PRESIDENT|    10|5000|   1|
| 7782| CLARK|  MANAGER|    10|2450|   2|
| 7369| SMITH|    CLERK|    10| 800|   3|
| 7788| SCOTT|  ANALYST|    20|3000|   1|
| 7566| JONES|  MANAGER|    20|2975|   2|
| 7876| ADAMS|    CLERK|    20|1100|   3|
| 7698| BLAKE|  MANAGER|    30|2850|   1|
| 7499| ALLEN| SALESMAN|    30|1600|   2|
| 7844|TURNER| SALESMAN|    30|1500|   3|
| 7521|  WARD| SALESMAN|    30|1250|   4|
| 7654|MARTIN| SALESMAN|    30|1250|   4|
| 7629|  ALEX| SALESMAN|    30|1150|   6|
+-----+------+---------+------+----+----+

पायस्पार्क कोड के लिए दृष्टिकोण

• विंडो फ़ंक्शन, पार्टीशनBy(col('sal').desc()) का उपयोग करके विभाग संख्या के आधार पर डेटा को विभाजित करता है और फिर orderBy(col('sal').desc()) का उपयोग करके वेतन द्वारा प्रत्येक विभाजन के भीतर डेटा को अवरोही क्रम में ऑर्डर करता है। वेरिएबल windowSpec अंतिम विंडो विनिर्देश रखता है।
• 'emp_df' वह डेटाफ़्रेम है जिसमें कर्मचारी डेटा शामिल है, जिसमें एम्पनो, ईनाम, जॉब, डेप्टनो और साल के कॉलम शामिल हैं।
• रैंक फ़ंक्शन को चयन कथन के भीतर 'F.rank().over(windowSpec)' का उपयोग करके वेतन कॉलम पर लागू किया जाता है। परिणामी कॉलम का उपनाम 'रैंक' है।
• यह एक डेटाफ्रेम, 'रैंकिंग_रिजल्ट_डीएफ' बनाएगा, जिसमें एम्पनो, एनेम, जॉब, डिप्टीनो और वेतन शामिल है। इसमें एक नया कॉलम 'रैंक' भी है, जो उनके विभाग के भीतर कर्मचारी के वेतन के रैंक को दर्शाता है।

आउटपुट:

परिणाम में प्रत्येक विभाग में वेतन रैंक होती है।

Q2. प्रत्येक विभाग के भीतर वेतन को सघन करें।

# Using Spark SQL
dense_df = spark.sql(
        """SELECT empno, ename, job, deptno, sal, 
        DENSE_RANK() OVER (PARTITION BY deptno ORDER BY sal DESC) 
        AS dense_rank FROM emp""")
dense_df.show()

# Using PySpark
windowSpec = Window.partitionBy(col('deptno')).orderBy(col('sal').desc())
dense_ranking_df=emp_df.select('empno', 'ename', 'job', 'deptno', 'sal', 
                      F.dense_rank().over(windowSpec).alias('dense_rank'))
dense_ranking_df.show()

# Output:-
+-----+------+---------+------+----+----------+
|empno| ename|      job|deptno| sal|dense_rank|
+-----+------+---------+------+----+----------+
| 7839|  KING|PRESIDENT|    10|5000|         1|
| 7782| CLARK|  MANAGER|    10|2450|         2|
| 7369| SMITH|    CLERK|    10| 800|         3|
| 7788| SCOTT|  ANALYST|    20|3000|         1|
| 7566| JONES|  MANAGER|    20|2975|         2|
| 7876| ADAMS|    CLERK|    20|1100|         3|
| 7698| BLAKE|  MANAGER|    30|2850|         1|
| 7499| ALLEN| SALESMAN|    30|1600|         2|
| 7844|TURNER| SALESMAN|    30|1500|         3|
| 7521|  WARD| SALESMAN|    30|1250|         4|
| 7654|MARTIN| SALESMAN|    30|1250|         4|
| 7629|  ALEX| SALESMAN|    30|1150|         5|
+-----+------+---------+------+----+----------+

पायस्पार्क कोड के लिए दृष्टिकोण

• सबसे पहले, विंडो फ़ंक्शन का उपयोग करके एक विंडो विनिर्देश बनाएं, जो 'emp_df' डेटाफ़्रेम को विभाग द्वारा विभाजित करता है और इसे 'sal' कॉलम में अवरोही क्रम में व्यवस्थित करता है।
• फिर, Dens_rank() फ़ंक्शन विंडो विनिर्देश पर लागू हो जाता है, जो क्रमबद्ध क्रम के आधार पर प्रत्येक विभाजन के भीतर प्रत्येक पंक्ति को एक सघन रैंक प्रदान करता है।
• अंत में, 'dense_ranking_df' नामक एक नया डेटाफ़्रेम emp_df (यानी, 'empno', 'ename', 'job', 'deptno', और 'sal') से विशिष्ट कॉलम चुनकर और एक नया कॉलम 'dense_rank' जोड़कर बनाया जाता है। इसमें विंडो फ़ंक्शन द्वारा गणना की गई सघन रैंकिंग मान शामिल हैं।
• अंत में, परिणामी डेटाफ़्रेम को सारणीबद्ध प्रारूप में प्रदर्शित करें।

आउटपुट:

परिणाम में वेतन-वार सघन रैंक है।

Q3. प्रत्येक विभाग के भीतर पंक्ति को क्रमांकित करें।

# Using Spark SQL 
row_df = spark.sql(
        """SELECT empno, ename, job, deptno, sal, 
        ROW_NUMBER() OVER (PARTITION BY deptno ORDER BY sal DESC)
         AS row_num FROM emp """)
row_df.show()

# Using PySpark code
windowSpec = Window.partitionBy(col('deptno')).orderBy(col('sal').desc())
row_num_df = emp_df.select('empno', 'ename', 'job', 'deptno', 'sal', 
               F.row_number().over(windowSpec).alias('row_num'))
row_num_df.show()

# Output:-
+-----+------+---------+------+----+-------+
|empno| ename|      job|deptno| sal|row_num|
+-----+------+---------+------+----+-------+
| 7839|  KING|PRESIDENT|    10|5000|      1|
| 7782| CLARK|  MANAGER|    10|2450|      2|
| 7369| SMITH|    CLERK|    10| 800|      3|
| 7788| SCOTT|  ANALYST|    20|3000|      1|
| 7566| JONES|  MANAGER|    20|2975|      2|
| 7876| ADAMS|    CLERK|    20|1100|      3|
| 7698| BLAKE|  MANAGER|    30|2850|      1|
| 7499| ALLEN| SALESMAN|    30|1600|      2|
| 7844|TURNER| SALESMAN|    30|1500|      3|
| 7521|  WARD| SALESMAN|    30|1250|      4|
| 7654|MARTIN| SALESMAN|    30|1250|      5|
| 7629|  ALEX| SALESMAN|    30|1150|      6|
+-----+------+---------+------+----+-------+

PySpark कोड के लिए दृष्टिकोण

• पहली पंक्ति window.partitionBy() और window.orderBy() फ़ंक्शंस का उपयोग करके गणना के लिए विंडो विनिर्देश को परिभाषित करती है। इस विंडो को डेप्टनो कॉलम द्वारा विभाजित किया गया है और सैल कॉलम द्वारा अवरोही क्रम में क्रमबद्ध किया गया है।
• दूसरी पंक्ति 'row_num_df' नामक एक नया डेटाफ़्रेम बनाती है, जो 'row_num' नामक एक अतिरिक्त कॉलम के साथ 'emp_df' का एक प्रक्षेपण है और इसमें पंक्ति संख्याओं का विवरण होता है।
• शो() फ़ंक्शन परिणामी डेटाफ़्रेम प्रदर्शित करता है, जो प्रत्येक कर्मचारी के एम्पनो, एननाम, जॉब, डिप्टो, सैल और रो_नम कॉलम दिखाता है।

आउटपुट:

आउटपुट में उनके वेतन के आधार पर उनके विभाग के प्रत्येक कर्मचारी की पंक्ति संख्या होगी।

Q4. प्रत्येक विभाग में वेतन का कुल योग चल रहा है।

# Using Spark SQL
running_sum_df = spark.sql(
          """SELECT empno, ename, job, deptno, sal, 
          SUM(sal) OVER (PARTITION BY deptno ORDER BY sal DESC) 
          AS running_total FROM emp
          """)
running_sum_df.show()

# Using PySpar
windowSpec = Window.partitionBy(col('deptno')).orderBy(col('sal').desc())
running_sum_sal_df= emp_df.select('empno', 'ename', 'job', 'deptno', 'sal', 
                         F.sum('sal').over(windowSpec).alias('running_total'))
running_sum_sal_df.show()

# Output:-
+-----+------+---------+------+----+-------------+
|empno| ename|      job|deptno| sal|running_total|
+-----+------+---------+------+----+-------------+
| 7839|  KING|PRESIDENT|    10|5000|         5000|
| 7782| CLARK|  MANAGER|    10|2450|         7450|
| 7369| SMITH|    CLERK|    10| 800|         8250|
| 7788| SCOTT|  ANALYST|    20|3000|         3000|
| 7566| JONES|  MANAGER|    20|2975|         5975|
| 7876| ADAMS|    CLERK|    20|1100|         7075|
| 7698| BLAKE|  MANAGER|    30|2850|         2850|
| 7499| ALLEN| SALESMAN|    30|1600|         4450|
| 7844|TURNER| SALESMAN|    30|1500|         5950|
| 7521|  WARD| SALESMAN|    30|1250|         8450|
| 7654|MARTIN| SALESMAN|    30|1250|         8450|
| 7629|  ALEX| SALESMAN|    30|1150|         9600|
+-----+------+---------+------+----+-------------+

दृष्टिकोण पायस्पार्क कोड के लिए

• सबसे पहले, एक विंडो विनिर्देश को "Window.partitionBy()" और "Window.orderBy()" विधियों का उपयोग करके परिभाषित किया गया है। "partitionBy()" विधि डेटा को "deptno" कॉलम द्वारा विभाजित करती है, जबकि "orderBy()" विधि डेटा को "sal" कॉलम द्वारा अवरोही क्रम में क्रमित करती है।
• इसके बाद, प्रत्येक विभाग के भीतर वेतन के चल रहे कुल की गणना करने के लिए "ओवर()" विधि का उपयोग करके "योग ()" फ़ंक्शन को "सैल" कॉलम पर लागू किया जाता है। परिणाम "running_sum_sal_df" नामक एक नए डेटाफ़्रेम में होगा, जिसमें कॉलम 'empno', 'ename', 'job', 'deptno', 'sal', और 'running_total' शामिल हैं।
• अंत में, क्वेरी का आउटपुट प्रदर्शित करने के लिए "running_sum_sal_df" डेटाफ़्रेम पर "शो()" विधि को कॉल किया जाता है। परिणामी डेटाफ़्रेम प्रत्येक कर्मचारी के कुल वेतन और नाम, विभाग संख्या और नौकरी जैसे अन्य विवरण दिखाता है।

आउटपुट:

आउटपुट में प्रत्येक विभाग के वेतन डेटा का कुल योग होगा।

Q5: प्रत्येक विभाग के भीतर अगला वेतन।

प्रत्येक विभाग में अगला वेतन जानने के लिए हम LEAD फ़ंक्शन का उपयोग करते हैं। 

लीड() विंडो फ़ंक्शन विंडो विभाजन की अगली पंक्ति में अभिव्यक्ति का मान प्राप्त करने में मदद करता है। यह प्रत्येक इनपुट कॉलम के लिए एक कॉलम लौटाता है, जहां प्रत्येक कॉलम में विंडो विभाजन के भीतर वर्तमान पंक्ति के ऊपर ऑफसेट पंक्ति के लिए इनपुट कॉलम का मान होगा। लीड फ़ंक्शन के लिए सिंटैक्स है:- लीड(कॉल, ऑफ़सेट=1, डिफ़ॉल्ट=कोई नहीं)।

# Using Spark SQL
next_sal_df = spark.sql(
    """SELECT empno, ename, job, deptno, sal, LEAD(sal, 1) 
    OVER (PARTITION BY deptno ORDER BY sal DESC) AS next_val FROM emp
    """)
next_sal_df.show()

# Output:-
+-----+------+---------+------+----+--------+
|empno| ename|      job|deptno| sal|next_val|
+-----+------+---------+------+----+--------+
| 7839|  KING|PRESIDENT|    10|5000|    2450|
| 7782| CLARK|  MANAGER|    10|2450|     800|
| 7369| SMITH|    CLERK|    10| 800|    null|
| 7788| SCOTT|  ANALYST|    20|3000|    2975|
| 7566| JONES|  MANAGER|    20|2975|    1100|
| 7876| ADAMS|    CLERK|    20|1100|    null|
| 7698| BLAKE|  MANAGER|    30|2850|    1600|
| 7499| ALLEN| SALESMAN|    30|1600|    1500|
| 7844|TURNER| SALESMAN|    30|1500|    1250|
| 7521|  WARD| SALESMAN|    30|1250|    1250|
| 7654|MARTIN| SALESMAN|    30|1250|    1150|
| 7629|  ALEX| SALESMAN|    30|1150|    null|
+-----+------+---------+------+----+--------+

# Using PySpark
windowSpec = Window.partitionBy(col('deptno')).orderBy(col('sal').desc())
next_salary_df = emp_df.select('empno', 'ename', 'job', 'deptno', 'sal', 
               F.lead('sal', offset=1, default=0).over(windowSpec).alias('next_val'))
next_salary_df.show()

# Output:-
+-----+------+---------+------+----+--------+
|empno| ename|      job|deptno| sal|next_val|
+-----+------+---------+------+----+--------+
| 7839|  KING|PRESIDENT|    10|5000|    2450|
| 7782| CLARK|  MANAGER|    10|2450|     800|
| 7369| SMITH|    CLERK|    10| 800|       0|
| 7788| SCOTT|  ANALYST|    20|3000|    2975|
| 7566| JONES|  MANAGER|    20|2975|    1100|
| 7876| ADAMS|    CLERK|    20|1100|       0|
| 7698| BLAKE|  MANAGER|    30|2850|    1600|
| 7499| ALLEN| SALESMAN|    30|1600|    1500|
| 7844|TURNER| SALESMAN|    30|1500|    1250|
| 7521|  WARD| SALESMAN|    30|1250|    1250|
| 7654|MARTIN| SALESMAN|    30|1250|    1150|
| 7629|  ALEX| SALESMAN|    30|1150|       0|
+-----+------+---------+------+----+--------+

PySpark कोड के लिए दृष्टिकोण

• सबसे पहले, विंडो फ़ंक्शन डेटाफ़्रेम की पंक्तियों को विभाग संख्या (डिप्टनो) द्वारा विभाजित करने और प्रत्येक विभाजन के भीतर वेतन को अवरोही क्रम में व्यवस्थित करने में मदद करता है।
• लीड () फ़ंक्शन को निम्नलिखित कर्मचारी के वेतन (1 की ऑफसेट के साथ) वापस करने के लिए प्रत्येक विभाजन के भीतर ऑर्डर किए गए 'सैल' कॉलम पर लागू किया जाता है, और कोई अगला कर्मचारी न होने की स्थिति में डिफ़ॉल्ट मान 0 होता है।
• परिणामी डेटाफ़्रेम 'नेक्स्ट_सैलरी_डीएफ' में कर्मचारी संख्या (एम्पनो), नाम (एनाम), नौकरी का शीर्षक (नौकरी), विभाग संख्या (डिप्टो), वर्तमान वेतन (सैल), और अगले वेतन (नेक्स्ट_वैल) के लिए कॉलम शामिल हैं।

आउटपुट:

आउटपुट में घटते वेतन के क्रम के आधार पर विभाग में अगले कर्मचारी का वेतन शामिल होता है। 

Q6. प्रत्येक विभाग में पिछला वेतन.

पिछले वेतन की गणना करने के लिए, हम LAG फ़ंक्शन का उपयोग करते हैं।

लैग फ़ंक्शन विंडो विभाजन के भीतर वर्तमान पंक्ति से पहले दिए गए ऑफसेट पर एक अभिव्यक्ति का मान लौटाता है। लैग फ़ंक्शन का सिंटैक्स है:- लैग(एक्सपीआर, ऑफसेट=1, डिफॉल्ट=कोई नहीं).ओवर(विंडोस्पेक)।

# Using Spark SQL
preious_sal_df = spark.sql(
    """SELECT empno, ename, job, deptno, sal, LAG(sal, 1) 
           OVER (PARTITION BY deptno ORDER BY sal DESC) 
           AS prev_val FROM emp
         """)
preious_sal_df.show()

# Output:-
+-----+------+---------+------+----+--------+
|empno| ename|      job|deptno| sal|prev_val|
+-----+------+---------+------+----+--------+
| 7839|  KING|PRESIDENT|    10|5000|    null|
| 7782| CLARK|  MANAGER|    10|2450|    5000|
| 7369| SMITH|    CLERK|    10| 800|    2450|
| 7788| SCOTT|  ANALYST|    20|3000|    null|
| 7566| JONES|  MANAGER|    20|2975|    3000|
| 7876| ADAMS|    CLERK|    20|1100|    2975|
| 7698| BLAKE|  MANAGER|    30|2850|    null|
| 7499| ALLEN| SALESMAN|    30|1600|    2850|
| 7844|TURNER| SALESMAN|    30|1500|    1600|
| 7521|  WARD| SALESMAN|    30|1250|    1500|
| 7654|MARTIN| SALESMAN|    30|1250|    1250|
| 7629|  ALEX| SALESMAN|    30|1150|    1250|
+-----+------+---------+------+----+--------+

# Using PySpark
windowSpec = Window.partitionBy(col('deptno')).orderBy(col('sal').desc())
prev_sal_df = emp_df.select('empno', 'ename', 'job', 'deptno', 'sal', 
                F.lag('sal', offset=1, default=0).over(windowSpec).alias('prev_val'))
prev_sal_df.show()

# Output:-
+-----+------+---------+------+----+--------+
|empno| ename|      job|deptno| sal|prev_val|
+-----+------+---------+------+----+--------+
| 7839|  KING|PRESIDENT|    10|5000|       0|
| 7782| CLARK|  MANAGER|    10|2450|    5000|
| 7369| SMITH|    CLERK|    10| 800|    2450|
| 7788| SCOTT|  ANALYST|    20|3000|       0|
| 7566| JONES|  MANAGER|    20|2975|    3000|
| 7876| ADAMS|    CLERK|    20|1100|    2975|
| 7698| BLAKE|  MANAGER|    30|2850|       0|
| 7499| ALLEN| SALESMAN|    30|1600|    2850|
| 7844|TURNER| SALESMAN|    30|1500|    1600|
| 7521|  WARD| SALESMAN|    30|1250|    1500|
| 7654|MARTIN| SALESMAN|    30|1250|    1250|
| 7629|  ALEX| SALESMAN|    30|1150|    1250|
+-----+------+---------+------+----+--------+

PySpark कोड के लिए दृष्टिकोण

• window.partitionBy(col('deptno')) विंडो विभाजन को निर्दिष्ट करता है। इसका मतलब है कि विंडो फ़ंक्शन प्रत्येक विभाग के लिए अलग-अलग काम करता है।
• फिर orderBy(col('sal').desc()) वेतन का क्रम निर्दिष्ट करता है और प्रत्येक विभाग के भीतर घटते क्रम में वेतन का आदेश देगा।
• F.lag('sal', offset=1, default=0).over(windowSpec).alias('prev_val') डेटाफ़्रेम 'prev_sal_df' में prev_val नामक एक नया कॉलम बनाता है।
• प्रत्येक पंक्ति के लिए, इस कॉलम में विंडोस्पेक द्वारा परिभाषित विंडो के भीतर पिछली पंक्ति से 'सैल' कॉलम का मान शामिल है।
• ऑफसेट=1 पैरामीटर इंगित करता है कि पिछली पंक्ति वर्तमान पंक्ति से एक पंक्ति पहले होनी चाहिए, और default=0 प्रत्येक विभाजन में पहली पंक्ति के लिए डिफ़ॉल्ट मान निर्दिष्ट करता है (क्योंकि पहली पंक्ति के लिए कोई पिछली पंक्ति नहीं है)।
• अंत में, prev_sal_df.show() परिणामी डेटाफ़्रेम प्रदर्शित करता है।

आउटपुट:

अवरोही क्रम में वेतन के आधार पर आउटपुट प्रत्येक विभाग के प्रत्येक कर्मचारी के लिए पिछले वेतन का प्रतिनिधित्व करता है।

Q7. प्रत्येक विभाग में पहला वेतन और प्रत्येक विभाग में प्रत्येक सदस्य से तुलना।

# Using Spark SQL
first_val_df = spark.sql("""SELECT empno, ename, job, deptno, sal, 
                   FIRST_VALUE(sal) OVER (PARTITION BY deptno ORDER BY sal DESC) 
                   AS first_val FROM emp """)
first_val_df.show()

# Using PySpark 
windowSpec = Window.partitionBy(col('deptno')).orderBy(col('sal').desc())
first_value_df = emp_df.select('empno', 'ename', 'job', 'deptno', 'sal', 
                   F.first('sal').over(windowSpec).alias('first_val'))
first_value_df.show()

# Output:-
+-----+------+---------+------+----+---------+
|empno| ename|      job|deptno| sal|first_val|
+-----+------+---------+------+----+---------+
| 7839|  KING|PRESIDENT|    10|5000|     5000|
| 7782| CLARK|  MANAGER|    10|2450|     5000|
| 7369| SMITH|    CLERK|    10| 800|     5000|
| 7788| SCOTT|  ANALYST|    20|3000|     3000|
| 7566| JONES|  MANAGER|    20|2975|     3000|
| 7876| ADAMS|    CLERK|    20|1100|     3000|
| 7698| BLAKE|  MANAGER|    30|2850|     2850|
| 7499| ALLEN| SALESMAN|    30|1600|     2850|
| 7844|TURNER| SALESMAN|    30|1500|     2850|
| 7521|  WARD| SALESMAN|    30|1250|     2850|
| 7654|MARTIN| SALESMAN|    30|1250|     2850|
| 7629|  ALEX| SALESMAN|    30|1150|     2850|
+-----+------+---------+------+----+---------+

PySpark कोड के लिए दृष्टिकोण

• सबसे पहले, एक विंडोस्पेक ऑब्जेक्ट बनाएं जो डेटा को विभाग संख्या (डिप्टनो) द्वारा विभाजित करता है और इसे अवरोही क्रम में वेतन (सैल) द्वारा ऑर्डर करता है।
• फिर पहले() विश्लेषणात्मक फ़ंक्शन को windowSpec द्वारा परिभाषित विंडो पर 'sal' कॉलम पर लागू करता है। यह फ़ंक्शन प्रत्येक विभाजन (यानी प्रत्येक विभाग समूह) के भीतर 'सैल' कॉलम का पहला मान 'सैल' को अवरोही क्रम में लौटाता है। परिणामी कॉलम का एक नया नाम है, 'first_val'।
• अब परिणामी डेटाफ़्रेम को असाइन करता है, जिसमें चयनित कॉलम और एक नया कॉलम, 'first_val' शामिल है, जो वेतन मानों के अवरोही क्रम के आधार पर प्रत्येक विभाग के लिए पहला उच्चतम वेतन दिखाता है, 'first_value_df' नामक एक नए वैरिएबल को।

आउटपुट:

आउटपुट किसी कर्मचारी डेटाफ़्रेम में प्रत्येक विभाग के लिए पहला उच्चतम वेतन दिखाता है।

निष्कर्ष

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

चाबी छीन लेना

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

यह केस स्टडी आपको पायस्पार्क फ़ंक्शंस को बेहतर ढंग से समझने में मदद करती है। यदि आपकी कोई राय या प्रश्न है तो नीचे टिप्पणी करें। मेरे साथ जुड़ें लिंक्डइन आगे की चर्चा के लिए. सीखते रखना!!!

इस लेख में दिखाया गया मीडिया एनालिटिक्स विद्या के स्वामित्व में नहीं है और इसका उपयोग लेखक के विवेक पर किया जाता है।

• एसईओ संचालित सामग्री और पीआर वितरण। आज ही प्रवर्धित हो जाओ।
• प्लेटोडेटा.नेटवर्क वर्टिकल जेनरेटिव एआई। स्वयं को शक्तिवान बनाएं। यहां पहुंचें।
• प्लेटोआईस्ट्रीम। Web3 इंटेलिजेंस। ज्ञान प्रवर्धित। यहां पहुंचें।
• प्लेटोईएसजी. कार्बन, क्लीनटेक, ऊर्जा, पर्यावरण, सौर, कचरा प्रबंधन। यहां पहुंचें।
• प्लेटोहेल्थ। बायोटेक और क्लिनिकल परीक्षण इंटेलिजेंस। यहां पहुंचें।
• स्रोत: https://www.analyticsvidhya.com/blog/2024/03/working-with-window-functions-in-pyspark/