मोंगोडीबी $stdDevPop

MongoDB में, $stdDevPop एकत्रीकरण पाइपलाइन ऑपरेटर अपने इनपुट मूल्यों के जनसंख्या मानक विचलन की गणना करता है।

इनपुट मान दस्तावेज़ों के समूह (अर्थात एक ही कुंजी द्वारा समूहीकृत किए गए दस्तावेज़) से हो सकते हैं, या वे एक दस्तावेज़ के भीतर कई फ़ील्ड हो सकते हैं।

सिंटैक्स

$stdDevPop ऑपरेटर दो सिंटैक्स का समर्थन करता है।

सिंटैक्स 1:

{ $stdDevPop: <expression> }

सिंटैक्स 2:

{ $stdDevPop: [ <expression1>, <expression2> ... ]  }

पहला सिंटैक्स एक तर्क को स्वीकार करता है और दूसरा सिंटैक्स कई तर्कों को स्वीकार करता है।

जब $group . में उपयोग किया जाता है चरण, आप केवल पहले सिंटैक्स का उपयोग कर सकते हैं। इस मामले में, $stdDevPop कुंजी द्वारा समान समूह को साझा करने वाले दस्तावेज़ों के समूह के लिए निर्दिष्ट व्यंजक का जनसंख्या मानक विचलन लौटाता है।

सिंटैक्स 1 के उदाहरण (एकल तर्क)

यहां कुछ उदाहरण दिए गए हैं जो सिंटैक्स 1 का उपयोग करते हैं।

समूहीकृत दस्तावेज़

यह उदाहरण $stdDevPop . का उपयोग करता है $group . के संयोजन के साथ कुंजी द्वारा समूहीकृत दस्तावेज़ों के समूह में मानक विचलन वापस करने के लिए।

मान लीजिए हमारे पास stonks . नामक संग्रह है निम्नलिखित दस्तावेजों के साथ:

{ "_id" : 1, "ticker" : "gme", "price" : 10 }
{ "_id" : 2, "ticker" : "gme", "price" : 40 }
{ "_id" : 3, "ticker" : "gme", "price" : 90 }
{ "_id" : 4, "ticker" : "gme", "price" : 180 }
{ "_id" : 5, "ticker" : "gme", "price" : 290 }
{ "_id" : 6, "ticker" : "gme", "price" : 390 }
{ "_id" : 7, "ticker" : "gme", "price" : 190 }
{ "_id" : 8, "ticker" : "gme", "price" : 90 }
{ "_id" : 9, "ticker" : "gme", "price" : 10 }
{ "_id" : 10, "ticker" : "jnj", "price" : 131 }
{ "_id" : 11, "ticker" : "jnj", "price" : 133 }
{ "_id" : 12, "ticker" : "jnj", "price" : 138 }
{ "_id" : 13, "ticker" : "jnj", "price" : 141 }
{ "_id" : 14, "ticker" : "jnj", "price" : 145 }
{ "_id" : 15, "ticker" : "jnj", "price" : 150 }
{ "_id" : 16, "ticker" : "jnj", "price" : 154 }
{ "_id" : 17, "ticker" : "jnj", "price" : 156 }
{ "_id" : 18, "ticker" : "jnj", "price" : 160 }

हम इन दस्तावेज़ों को उनके ticker . द्वारा समूहित कर सकते हैं फ़ील्ड, और फिर $stdDevPop . का उपयोग करें price . का जनसंख्या मानक विचलन लौटाने के लिए प्रत्येक समूह के लिए फ़ील्ड:

db.stonks.aggregate(
   [
     {
       $group:
          {
            _id: "$ticker",
            standardDeviation: { $stdDevPop: "$price" }
          }
     }
   ]
)

परिणाम:

{ "_id" : "gme", "standardDeviation" : 123.7380746218039 }
{ "_id" : "jnj", "standardDeviation" : 9.752492558885207 }

हम देख सकते हैं कि gme jnj . की तुलना में बहुत अधिक मानक विचलन है ।

सरणी

यह उदाहरण $stdDevPop . पर लागू होता है एक एकल दस्तावेज़ के लिए जिसमें मानों की एक सरणी वाला फ़ील्ड होता है।

यह विकल्प केवल एकल तर्क सिंटैक्स का उपयोग करते समय उपलब्ध होता है। बहु-तर्क सिंटैक्स का उपयोग करते समय सरणियों को अनदेखा कर दिया जाता है (इस पर और अधिक नीचे)।

मान लीजिए हमारे पास players . नामक संग्रह है निम्नलिखित दस्तावेजों के साथ:

{ "_id" : 1, "player" : "Homer", "scores" : [ 1, 7, 2, 3, 8, 7, 1 ] }
{ "_id" : 2, "player" : "Marge", "scores" : [ 0, 1, 8, 17, 18, 8 ] }
{ "_id" : 3, "player" : "Bart", "scores" : [ 15, 11, 8, 0, 1, 3 ] }
{ "_id" : 4, "player" : "Brian", "scores" : [ 7 ] }
{ "_id" : 5, "player" : "Farnsworth", "scores" : [ ] }
{ "_id" : 6, "player" : "Meg", "scores" : null }

हम $stdDevPop . लागू कर सकते हैं scores . तक प्रत्येक दस्तावेज़ में फ़ील्ड:

db.players.aggregate(
   [
     {
       $project:
          {
            standardDeviation: { $stdDevPop: "$scores" }
          }
     }
   ]
)

परिणाम:

{ "_id" : 1, "standardDeviation" : 2.849991049037143 }
{ "_id" : 2, "standardDeviation" : 6.968181653455625 }
{ "_id" : 3, "standardDeviation" : 5.467073155618908 }
{ "_id" : 4, "standardDeviation" : 0 }
{ "_id" : 5, "standardDeviation" : null }
{ "_id" : 6, "standardDeviation" : null }

इस मामले में, पहले तीन दस्तावेज़ों ने विभिन्न संख्याओं के लिए मानक विचलन लौटाया जो उनके संबंधित सरणियों में थे।

दस्तावेज़ 4 के परिणामस्वरूप 0 . का मानक विचलन हुआ . ऐसा इसलिए है क्योंकि हमने सरणी में केवल एक संख्या प्रदान की है।

दस्तावेज़ 5 लौटा null क्योंकि हमने एक खाली सरणी प्रदान की है।

दस्तावेज़ 6 लौटा null क्योंकि हमने null प्रदान किया है तर्क के रूप में।

सिंटैक्स 2 का उदाहरण (एकाधिक तर्क)

दूसरे सिंटैक्स में $stdDevPop . प्रदान करना शामिल है एक से अधिक तर्क के साथ। $stdDevPop फिर सभी दिए गए तर्कों के आधार पर मानक विचलन की गणना करता है।

मान लीजिए हमारे पास data . नामक संग्रह है निम्नलिखित दस्तावेजों के साथ:

{ "_id" : 1, "a" : 1, "b" : 2, "c" : 3, "d" : 4 }
{ "_id" : 2, "a" : 1, "b" : 2, "c" : 3, "d" : [ 4 ] }
{ "_id" : 3, "a" : 1, "b" : 2, "c" : 3, "d" : "Hey" }

हम $stdDevPop . का उपयोग कर सकते हैं a . का जनसंख्या मानक विचलन लौटाने के लिए , b , c , और d प्रत्येक दस्तावेज़ के क्षेत्र:

db.data.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevPop: [ "$a", "$b", "$c", "$d" ] }
          }
     }
   ]
)

परिणाम:

{ "_id" : 1, "result" : 1.118033988749895 }
{ "_id" : 2, "result" : 0.816496580927726 }
{ "_id" : 3, "result" : 0.816496580927726 }

दस्तावेज़ 1 अपने 1 . के इनपुट मानों के आधार पर मानक विचलन लौटाता है , 2 , 3 , और 4 ।

हालांकि, पिछले दो दस्तावेज़ों ने केवल 1 . के इनपुट मानों के लिए मानक विचलन लौटाया है , 2 , और 3 . $stdDevPop ऑपरेटर ने उनके d . पर ध्यान नहीं दिया खेत।

ऐसा क्यों है?

इसके काम करने का तरीका यह है कि $stdDevPop गैर-संख्यात्मक मानों की उपेक्षा करता है। तो इस मामले में यह नजरअंदाज कर दिया "Hey" दस्तावेज़ 3 में और शेष (संख्यात्मक) फ़ील्ड से जनसंख्या मानक विचलन की गणना की।

दस्तावेज़ 2 के लिए, इसका d फ़ील्ड में एक सरणी है। जैसा कि बताया गया है, $stdDevPop बहु-तर्क सिंटैक्स का उपयोग करते समय ऑपरेटर सरणियों को अनदेखा करता है। अधिक सटीक रूप से, यह इस संदर्भ में उपयोग किए जाने पर सरणियों को गैर-संख्यात्मक मानों के रूप में मानता है। और जैसा कि बताया गया है, $stdDevPop गैर-संख्यात्मक मानों की उपेक्षा करता है।

यदि सभी मान गैर-संख्यात्मक हैं, तो $stdDevPop रिटर्न null ।

अनुपलब्ध फ़ील्ड

बहु-तर्क सिंटैक्स का उपयोग करते समय, $stdDevPop किसी भी लापता फ़ील्ड को अनदेखा करता है। यही है, यदि आप किसी ऐसे क्षेत्र की आपूर्ति करते हैं जो मौजूद नहीं है, तो वह इसे अनदेखा कर देता है। यदि कोई भी फ़ील्ड मौजूद नहीं है, तो यह null लौटाता है ।

उदाहरण:

db.data.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevPop: [ "$a", "$b", "$c", "$d", "$e" ] }
          }
     }
   ]
)

परिणाम:

{ "_id" : 1, "result" : 1.118033988749895 }
{ "_id" : 2, "result" : 0.816496580927726 }
{ "_id" : 3, "result" : 0.816496580927726 }

इस मामले में मैंने एक अतिरिक्त क्षेत्र प्रदान किया ($e ) जो दस्तावेज़ में मौजूद नहीं है। $stdDevPop करने वाले . शेष फ़ील्ड के आधार पर मानक विचलन की गणना की मौजूद है।

हालांकि, यहां क्या होता है जब कोई नहीं फ़ील्ड मौजूद हैं:

db.data.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevPop: [ "$x", "$y", "$z" ] }
          }
     }
   ]
)

परिणाम:

{ "_id" : 1, "result" : null }
{ "_id" : 2, "result" : null }
{ "_id" : 3, "result" : null }

परिणाम null है सभी दस्तावेज़ों के लिए।

एकल-तर्क सिंटैक्स का उपयोग करते समय, अनुपलब्ध फ़ील्ड का परिणाम null होता है ।

उदाहरण:

db.stonks.aggregate(
   [
     {
       $group:
          {
            _id: "$ticker",
            standardDeviation: { $stdDevPop: "$oops!" }
          }
     }
   ]
)

परिणाम:

{ "_id" : "gme", "standardDeviation" : null }
{ "_id" : "jnj", "standardDeviation" : null }

उपलब्ध चरण

$stdDevPop निम्नलिखित चरणों में उपलब्ध है:

• $group
• $project
• $addFields
• $set
• $replaceRoot
• $replaceWith
• $match चरण जिसमें एक $expr . शामिल है अभिव्यक्ति

नमूना मानक विचलन की गणना करें

MongoDB देखें $stdDevSamp अगर आपको नमूना . प्राप्त करने की आवश्यकता है जनसंख्या . के विपरीत मानक विचलन मानक विचलन। यह ऑपरेटर तब उपयोगी होता है जब आपके मूल्यों में डेटा की आबादी का एक नमूना शामिल होता है जिससे जनसंख्या के बारे में सामान्यीकरण किया जा सके।