Julia 1.0 - Missing Values

लापता मूल्य




julia

लापता मूल्य

जूलिया सांख्यिकीय अर्थों में लापता मूल्यों का प्रतिनिधित्व करने के लिए समर्थन प्रदान करता है, यह उन स्थितियों के लिए है जहां एक अवलोकन में एक चर के लिए कोई मूल्य उपलब्ध नहीं है, लेकिन सैद्धांतिक रूप से एक मान्य मूल्य मौजूद है। लापता वस्तु के माध्यम से गुम मानों का प्रतिनिधित्व किया जाता है, जो कि Missing के प्रकार का एकल उदाहरण है। missing SQL में NULL और R में NULL बराबर है, और अधिकांश स्थितियों में उनकी तरह व्यवहार करता है।

गुम मानों का प्रसार

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

julia> missing + 1
missing

julia> "a" * missing
missing

julia> abs(missing)
missing

जैसा कि missing एक सामान्य जूलिया वस्तु है, यह प्रसार नियम केवल उन कार्यों के लिए काम करता है जिन्होंने इस व्यवहार को लागू करने का विकल्प चुना है। यह या तो Missing तर्कों के लिए परिभाषित एक विशिष्ट विधि के माध्यम से प्राप्त किया जा सकता है, या बस इस प्रकार के तर्कों को स्वीकार करके, और उन कार्यों को पारित कर सकता है जो उन्हें प्रचारित करते हैं (जैसे मानक ऑपरेटर)। संकुल को इस बात पर विचार करना चाहिए कि क्या नए कार्यों को परिभाषित करते समय लापता मूल्यों को प्रचारित करना समझ में आता है, और यदि ऐसा है तो तरीकों को उचित रूप से परिभाषित करें। किसी फ़ंक्शन के लिए एक missing मान पास करना जिसके लिए किसी भी प्रकार के तर्कों को स्वीकार करने की कोई विधि नहीं है, एक MethodError फेंकता है, जैसे किसी अन्य प्रकार के लिए।

समानता और तुलना ऑपरेटरों

मानक समानता और तुलना ऑपरेटर ऊपर प्रस्तुत प्रचार नियम का पालन करते हैं: यदि कोई ऑपरेंड missing , तो परिणाम missing । कुछ उदाहरण निम्नलिखित हैं

julia> missing == 1
missing

julia> missing == missing
missing

julia> missing < 1
missing

julia> 2 >= missing
missing

विशेष रूप से, ध्यान दें कि missing == missing रिटर्न missing , इसलिए == उपयोग यह परीक्षण करने के लिए नहीं किया जा सकता है कि मूल्य गायब है या नहीं। यह जांचने के लिए कि क्या x missing , ismissing(x) उपयोग करें।

विशेष तुलना ऑपरेटर isequal और === प्रचार नियम के अपवाद हैं: वे हमेशा एक Bool मान लौटाते हैं, यहां तक ​​कि missing मानों की उपस्थिति में, missing के बराबर और किसी भी अन्य मूल्य से अलग होने पर विचार करते हैं। इसलिए उनका उपयोग यह परीक्षण करने के लिए किया जा सकता है कि क्या कोई मूल्य missing

julia> missing === 1
false

julia> isequal(missing, 1)
false

julia> missing === missing
true

julia> isequal(missing, missing)
true

isless ऑपरेटर एक और अपवाद है: missing को किसी भी अन्य मूल्य से अधिक माना जाता है। इस ऑपरेटर का उपयोग sort रूप से किया जाता है, जो कि अन्य सभी मूल्यों के बाद missing मान रखता missing

julia> isless(1, missing)
true

julia> isless(missing, Inf)
false

julia> isless(missing, missing)
false

लॉजिकल ऑपरेटर्स

लॉजिकल (या बूलियन) ऑपरेटर | , और xor एक और विशेष मामला है, क्योंकि वे केवल missing मूल्यों का प्रचार करते हैं जब यह तार्किक रूप से आवश्यक होता है। इन ऑपरेटरों के लिए, परिणाम अनिश्चित है या नहीं, यह विशेष ऑपरेशन पर निर्भर करता है, तीन-मूल्यवान तर्क के अच्छी तरह से स्थापित नियमों का पालन करता है जो NULL द्वारा SQL और NA में R पर NA हैं। यह सार परिभाषा वास्तव में अपेक्षाकृत प्राकृतिक से मेल खाती है व्यवहार जो ठोस उदाहरणों के माध्यम से सबसे अच्छा समझाया गया है।

आइए हम इस सिद्धांत को तार्किक या "ऑपरेटर" के साथ स्पष्ट करें । बूलियन लॉजिक के नियमों का पालन करना, यदि ऑपरेंड्स में से एक true , तो दूसरे ऑपरेंड के मूल्य का परिणाम पर प्रभाव नहीं पड़ता है, जो हमेशा true

julia> true | true
true

julia> true | false
true

julia> false | true
true

इस अवलोकन के आधार पर, हम यह निष्कर्ष निकाल सकते हैं कि यदि कोई एक ऑपरेंड true और दूसरा missing , तो हम जानते हैं कि परिणाम किसी एक ऑपरेंड के वास्तविक मूल्य के बारे में अनिश्चितता के बावजूद true है। यदि हम दूसरे ऑपरेंड के वास्तविक मूल्य का निरीक्षण करने में सक्षम थे, तो यह केवल true या false हो सकता true , और दोनों ही मामलों में परिणाम true होगा। इसलिए, इस विशेष मामले में, लापताता प्रचार नहीं करती है

julia> true | missing
true

julia> missing | true
true

इसके विपरीत, यदि ऑपरेंड में से एक false , तो परिणाम दूसरे ऑपरेंड के मूल्य के आधार पर या तो true या false हो सकता है। इसलिए, यदि वह ऑपरेंड missing , तो परिणाम भी missing होना है

julia> false | true
true

julia> true | false
true

julia> false | false
false

julia> false | missing
missing

julia> missing | false
missing

तार्किक "और" ऑपरेटर & का व्यवहार समान है | ऑपरेटर, इस अंतर के साथ कि लापता होने का प्रसार नहीं होता है जब ऑपरेंड में से एक false । उदाहरण के लिए, जब कि पहले ऑपरेंड का मामला है

julia> false & false
false

julia> false & true
false

julia> false & missing
false

दूसरी ओर, लापता होने का प्रचार तब होता है जब किसी एक ऑपरेंड के true , उदाहरण के लिए पहले वाला

julia> true & true
true

julia> true & false
false

julia> true & missing
missing

अंत में, "एक्सक्लूसिव या" लॉजिकल ऑपरेटर xor हमेशा missing मान का प्रचार करता है, क्योंकि दोनों ऑपरेंड का हमेशा परिणाम पर प्रभाव पड़ता है। यह भी ध्यान दें कि नकार ऑपरेटर ! जब ऑपरेंड अन्य यूनिरी ऑपरेटर्स की तरह ही missing होता है तो रिटर्न मिलता missing

नियंत्रण प्रवाह और लघु-परिचालित संचालक

नियंत्रण प्रवाह संचालकों सहित if , while और टर्नरी ऑपरेटर x ? y : z x ? y : z लापता मानों की अनुमति नहीं देता है। इसका कारण अनिश्चितता है कि क्या वास्तविक मूल्य true या false यदि हम इसे देख सकते हैं, जिसका अर्थ है कि हमें यह नहीं पता है कि कार्यक्रम को कैसे व्यवहार करना चाहिए। इस संदर्भ में एक missing मान TypeError ही एक TypeError फेंक दिया जाता है

julia> if missing
           println("here")
       end
ERROR: TypeError: non-boolean (Missing) used in boolean context

इसी कारण से, ऊपर प्रस्तुत तार्किक ऑपरेटरों के विपरीत, शॉर्ट-सर्कुलेटिंग बूलियन ऑपरेटर्स && और | उन परिस्थितियों में missing मानों की अनुमति न दें जहां ऑपरेंड का मूल्य निर्धारित करता है कि अगले ऑपरेंड का मूल्यांकन किया गया है या नहीं। उदाहरण के लिए

julia> missing || false
ERROR: TypeError: non-boolean (Missing) used in boolean context

julia> missing && false
ERROR: TypeError: non-boolean (Missing) used in boolean context

julia> true && missing && false
ERROR: TypeError: non-boolean (Missing) used in boolean context

दूसरी ओर, कोई भी त्रुटि नहीं डाली जाती है जब परिणाम को missing मानों के बिना निर्धारित किया जा सकता है। यह वह स्थिति है जब missing ऑपरेंड का मूल्यांकन करने से पहले कोड शॉर्ट-सर्किट करता missing , और जब missing ऑपरेंड अंतिम होता है

julia> true && missing
missing

julia> false && missing
false

लापता मूल्यों के साथ आता है

लापता मूल्यों वाले एरे को अन्य सरणियों की तरह बनाया जा सकता है

julia> [1, missing]
2-element Array{Union{Missing, Int64},1}:
 1
  missing

जैसा कि इस उदाहरण से पता चलता है, इस तरह के सरणियों का तत्व प्रकार है Union{Missing, T} , T के साथ गैर-लापता मान। यह बस इस तथ्य को दर्शाता है कि सरणी प्रविष्टियाँ टाइप T (यहाँ, Int64 ) या टाइप Missing । इस प्रकार की सरणी एक Array{T} बराबर एक कुशल मेमोरी स्टोरेज का उपयोग करती है, जो Array{UInt8} एंट्री के प्रकार (यानी चाहे वह Missing या T ) का संकेत देता है, के साथ संयुक्त वास्तविक मूल्यों को धारण करता है।

लापता मानों की अनुमति देने वाले एरर्स का निर्माण मानक सिंटैक्स के साथ किया जा सकता है। अनुपलब्ध मानों से भरे सरणियों को बनाने के लिए Array{Union{Missing, T}}(missing, dims) का उपयोग करें:

julia> Array{Union{Missing, String}}(missing, 2, 3)
2×3 Array{Union{Missing, String},2}:
 missing  missing  missing
 missing  missing  missing

missing मानों के लिए अनुमति देने वाला एक सरणी लेकिन जिसमें ऐसा कोई मान नहीं है, उसे किसी सरणी में वापस परिवर्तित किया जा सकता है जो convert मूल्यों का उपयोग करके लापता मानों की अनुमति नहीं देता है। यदि सरणी में missing मान हैं, तो रूपांतरण के दौरान एक MethodError फेंक दिया जाता है

julia> x = Union{Missing, String}["a", "b"]
2-element Array{Union{Missing, String},1}:
 "a"
 "b"

julia> convert(Array{String}, x)
2-element Array{String,1}:
 "a"
 "b"

julia> y = Union{Missing, String}[missing, "b"]
2-element Array{Union{Missing, String},1}:
 missing
 "b"

julia> convert(Array{String}, y)
ERROR: MethodError: Cannot `convert` an object of type Missing to an object of type String

स्किपिंग वैल्यूज़

चूंकि missing मान मानक गणितीय ऑपरेटरों के साथ प्रचारित करते हैं, इसलिए कमी कार्य missing जब सरणियों पर कॉल किया जाता है जिसमें लापता मान होते हैं

julia> sum([1, missing])
missing

इस स्थिति में, अनुपलब्ध मानों को छोड़ने के लिए skipmissing फ़ंक्शन का उपयोग करें

julia> sum(skipmissing([1, missing]))
1

यह सुविधा फ़ंक्शन एक पुनरावृत्त रिटर्न देता है जो missing मानों को कुशलतापूर्वक फ़िल्टर करता है। इसलिए इसका उपयोग किसी भी फ़ंक्शन के साथ किया जा सकता है जो पुनरावृत्तियों का समर्थन करता है

julia> maximum(skipmissing([3, missing, 2, 1]))
3

julia> mean(skipmissing([3, missing, 2, 1]))
2.0

julia> mapreduce(sqrt, +, skipmissing([3, missing, 2, 1]))
4.146264369941973

गैर- missing मान निकालने और उन्हें एक सरणी में संग्रहीत | लिए | का उपयोग करें

julia> collect(skipmissing([3, missing, 2, 1]))
3-element Array{Int64,1}:
 3
 2
 1

Arrays पर तार्किक संचालन

तार्किक ऑपरेटरों के लिए ऊपर वर्णित तीन-मूल्यवान तर्क का उपयोग सरणियों पर लागू तार्किक कार्यों द्वारा भी किया जाता है। इस प्रकार, जब भी परिणाम missing प्रविष्टि के वास्तविक मूल्य को जाने बिना परिणाम निर्धारित नहीं किया जा सकता है, तब == ऑपरेटर रिटर्न का उपयोग करके सरणी समानता परीक्षण। व्यवहार में, इसका मतलब यह है कि यदि अनुपलब्ध तुलना सारणियों के सभी गैर-लापता मान समान हैं, लेकिन एक या दोनों सरणियों में लापता मान शामिल हैं (संभवतः विभिन्न पदों पर)

julia> [1, missing] == [2, missing]
false

julia> [1, missing] == [1, missing]
missing

julia> [1, 2, missing] == [1, missing, 2]
missing

एकल मानों के लिए, missing मानों को अन्य missing मानों के बराबर isequal लिए isequal का उपयोग करें लेकिन गैर-लापता मानों से अलग

julia> isequal([1, missing], [1, missing])
true

julia> isequal([1, 2, missing], [1, missing, 2])
false

| कार्य और | भी तीन-मूल्यवान तर्क के नियमों का पालन करते हैं, जब परिणाम निर्धारित नहीं किया जा सकता है तो missing हो जाता है

julia> all([true, missing])
missing

julia> all([false, missing])
false

julia> any([true, missing])
true

julia> any([false, missing])
missing