मुझे "अज्ञात" और "लापता" मूल्यों को एक चर में कैसे संग्रहीत करना चाहिए, जबकि अभी भी "अज्ञात" और "लापता" के बीच अंतर को बनाए रखना है?

57

इस "अकादमिक" प्रश्न पर विचार करें। मैं समय-समय पर NULL से बचने के बारे में सोचता रहा हूं और यह एक उदाहरण है जहां मैं संतोषजनक समाधान नहीं कर सकता।

आइए मान लें कि मैं मापों को संग्रहीत करता हूं जहां अवसरों पर माप असंभव (या लापता) होने के लिए जाना जाता है। मैं NULL से बचते हुए एक वैरिएबल में उस "खाली" मान को स्टोर करना चाहूंगा। अन्य समय मान अज्ञात हो सकता है। इसलिए, एक निश्चित समय-सीमा के लिए माप होने से, उस समय अवधि के भीतर माप के बारे में एक क्वेरी 3 प्रकार की प्रतिक्रियाएं दे सकती है:

  • उस समय वास्तविक माप (उदाहरण के लिए, सहित कोई भी संख्यात्मक मान 0)
  • एक "लापता" / "खाली" मूल्य (यानी, एक माप किया गया था, और उस बिंदु पर मूल्य खाली होने के लिए जाना जाता है)।
  • अज्ञात मान (अर्थात, उस बिंदु पर कोई माप नहीं किया गया है। यह खाली हो सकता है, लेकिन यह कोई अन्य मूल्य भी हो सकता है)।

महत्वपूर्ण स्पष्टीकरण:

मान लें कि आपके पास get_measurement()"खाली", "अज्ञात" और प्रकार "पूर्णांक" का मान लौटाने वाला एक फ़ंक्शन था । संख्यात्मक मान होने से तात्पर्य है कि रिटर्न वैल्यू (गुणन, विभाजन, ...) पर कुछ निश्चित संचालन किए जा सकते हैं, लेकिन NULL पर इस तरह के संचालन का उपयोग करने पर एप्लिकेशन क्रैश हो जाएगा यदि नहीं पकड़ा गया।

मैं कोड लिखना, NULL जाँच से बचना चाहूँगा, उदाहरण के लिए (छद्मकोश)

>>> value = get_measurement()  # returns `2`
>>> print(value * 2)
4

>>> value = get_measurement()  # returns `Empty()`
>>> print(value * 2)
Empty()

>>> value = get_measurement()  # returns `Unknown()`
>>> print(value * 2)
Unknown()

ध्यान दें कि कोई भी printबयान अपवाद नहीं हुआ (जैसा कि कोई NULLs का उपयोग नहीं किया गया था)। इसलिए खाली और अज्ञात मान आवश्यक के रूप में प्रचारित करेंगे और जांचेंगे कि क्या मूल्य वास्तव में "अज्ञात" या "खाली" है जब तक कि वास्तव में आवश्यक हो (जैसे कि मूल्य कहीं पर संग्रहीत / अनुक्रमित करना)।

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

data-structures  type-systems  data-types 
— exhuma
स्रोत
19
आप "माप किए गए लेकिन खाली मूल्य" बनाम "कोई माप नहीं" को अलग करना चाहते हैं? वास्तव में, "माप किया गया लेकिन खाली मूल्य" का क्या अर्थ है? क्या मान्य मान उत्पन्न करने में सेंसर विफल रहा? उस मामले में, यह कैसे "अज्ञात" से अलग है? आप समय पर वापस जाने और सही मूल्य प्राप्त करने में सक्षम नहीं होंगे।
— डेवजी
3
@DaveG एक सर्वर में CPU की संख्या प्राप्त करना मान लें। यदि सर्वर बंद है, या बंद कर दिया गया है, तो यह मान बस अस्तित्व में नहीं है। यह एक माप होगा जिसका कोई मतलब नहीं है (शायद "लापता" / "खाली" सर्वोत्तम शब्द नहीं हैं)। लेकिन मूल्य निरर्थक होने के लिए "ज्ञात" है। यदि सर्वर मौजूद है, लेकिन मूल्य को प्राप्त करने की प्रक्रिया क्रैश हो जाती है, तो इसे मापना वैध है, लेकिन "अज्ञात" मान के परिणामस्वरूप विफल हो जाता है।
— exhuma
2
@exhuma मैं इसे "लागू नहीं" के रूप में वर्णित करूंगा।
— विंसेंट
6
जिज्ञासा से बाहर, आप किस तरह का माप ले रहे हैं जहां "खाली" बस जो भी पैमाने के शून्य के बराबर नहीं है? "अज्ञात" / "लापता" मैं उपयोगी हो सकता है जैसे कि यदि कोई सेंसर हुक नहीं है या यदि सेंसर का कच्चा आउटपुट एक कारण या किसी अन्य के लिए कचरा है, लेकिन हर मामले में "खाली" हो सकता है जो मैं लगातार सोच सकता हूं द्वारा प्रतिनिधित्व किया 0, []या {}(अदिश 0, खाली सूची, और खाली नक्शा, क्रमशः)। इसके अलावा, "लापता" / "अज्ञात" मूल्य मूल रूप से वही है जो nullइसके लिए है - यह दर्शाता है कि वहां कोई वस्तु हो सकती है, लेकिन वहां नहीं है।
— निक हार्टले
7
इसके लिए आप जो भी समाधान करते हैं, वह अपने आप से पूछना सुनिश्चित करें कि क्या यह उसी तरह की समस्याओं से ग्रस्त है जो आपको पहले स्थान पर नल को खत्म करना चाहते हैं।
— रे

जवाबों:

85

ऐसा करने का सामान्य तरीका, कम से कम कार्यात्मक भाषाओं के साथ भेदभावपूर्ण संघ का उपयोग करना है। यह तब एक मूल्य है जो एक वैध इंट में से एक है, एक मूल्य जो "लापता" या "अज्ञात" को दर्शाता है एक मान को दर्शाता है। F # में, यह कुछ इस तरह दिख सकता है:

type Measurement =
    | Reading of value : int
    | Missing
    | Unknown of value : RawData

एक Measurementमान तब होगा Reading, एक इंट वैल्यू के साथ, या एक Missing, या Unknownकच्चे डेटा के साथ value(यदि आवश्यक हो)।

हालाँकि, यदि आप एक ऐसी भाषा का उपयोग नहीं कर रहे हैं जो भेदभाव वाली यूनियनों, या उनके समकक्षों का समर्थन करती है, तो यह पैटर्न आपके लिए बहुत उपयोग की संभावना नहीं है। तो वहाँ, आप उदाहरण के लिए एक वर्ग का उपयोग कर सकते हैं जिसमें एक एनम फ़ील्ड है जो बताता है कि तीनों में से कौन सा सही डेटा है।

— डेविड अरनो
स्रोत
7
आप OO भाषाओं में योग कर सकते हैं, लेकिन उन्हें कार्य करने के लिए बायलर प्लेट का एक अच्छा सा हिस्सा है stackoverflow.com/questions/3151702/…
— jk।
11
"गैर-कार्यात्मक भाषाओं में] यह पैटर्न आपके बहुत काम आने की संभावना नहीं है" - यह OOP में एक बहुत ही सामान्य पैटर्न है। GOF में इस पैटर्न की भिन्नता है, और C ++ जैसी भाषाएं इसे एनकोड करने के लिए देशी निर्माण प्रदान करती हैं।
— कोनराड रुडोल्फ
14
@jk। हां, उनकी गिनती नहीं है (मुझे लगता है कि वे ऐसा करते हैं; वे सुरक्षा के अभाव में इस परिदृश्य में बहुत बुरे हैं)। मेरा मतलब था std::variant(और इसके आध्यात्मिक पूर्ववर्तियों)।
— कोनराड रुडोल्फ
2
@ ईवन नहीं, यह कह रहा है कि "मापन एक डेटा प्रकार है जो या तो ... या ..." है।
— कोनराड रुडोल्फ
2
@DavidArno अच्छी तरह से यहां तक ​​कि DU के बिना भी OOP में इसके लिए एक "विहित" समाधान है, जो मान्य और अमान्य मूल्यों के लिए उपवर्गों के साथ मूल्यों का एक सुपरक्लास है। लेकिन यह शायद बहुत दूर जा रहा है (और व्यवहार में ऐसा लगता है कि अधिकांश कोड आधार इसके लिए एक झंडे के पक्ष में उपवर्ग पॉलीमोर्फिज़्म को बढ़ाते हैं, जैसा कि अन्य उत्तरों में दिखाया गया है)।
— कोनराड रुडोल्फ
58

यदि आप पहले से ही नहीं जानते हैं कि एक सनक क्या है, तो आज सीखने के लिए एक महान दिन होगा। मेरे यहाँ OO प्रोग्रामर के लिए एक सौम्य परिचय है:

https://ericlippert.com/2013/02/21/monads-part-one/

आपका परिदृश्य "शायद सन्यासी" का एक छोटा विस्तार है, जिसे Nullable<T>C # और Optional<T>अन्य भाषाओं में भी जाना जाता है ।

मान लीजिए कि आपके पास मठ का प्रतिनिधित्व करने के लिए एक सार प्रकार है:

abstract class Measurement<T> { ... }

और फिर तीन उपवर्ग:

final class Unknown<T> : Measurement<T> { ... a singleton ...}
final class Empty<T> : Measurement<T> { ... a singleton ... }
final class Actual<T> : Measurement<T> { ... a wrapper around a T ...}

हमें बिंद के कार्यान्वयन की आवश्यकता है:

abstract class Measurement<T>
{ 
    public Measurement<R> Bind(Func<T, Measurement<R>> f)
  {
    if (this is Unknown<T>) return Unknown<R>.Singleton;
    if (this is Empty<T>) return Empty<R>.Singleton;
    if (this is Actual<T>) return f(((Actual<T>)this).Value);
    throw ...
  }

इससे आप बिंद के इस सरलीकृत संस्करण को लिख सकते हैं:

public Measurement<R> Bind(Func<A, R> f) 
{
  return this.Bind(a => new Actual<R>(f(a));
}

और अब आप कर रहे हैं। आपके Measurement<int>हाथ में है। आप इसे दोगुना करना चाहते हैं:

Measurement<int> m = whatever;
Measurement<int> doubled = m.Bind(a => a * 2);
Measurement<string> asString = m.Bind(a => a.ToString());

और तर्क का पालन करें; अगर mहै Empty<int>तो asStringहै Empty<String>, उत्कृष्ट।

इसी तरह, अगर हमारे पास है

Measurement<int> First()

तथा

Measurement<double> Second(int i);

फिर हम दो मापों को जोड़ सकते हैं:

Measurement<double> d = First().Bind(Second);

और फिर, अगर First()है Empty<int>तो dहै Empty<double>और इतने पर।

बाइंड ऑपरेशन को सही करने के लिए महत्वपूर्ण कदम है । इसके बारे में कठिन सोचें।

— एरिक लिपर्ट
स्रोत
4
मोनाड्स (शुक्र है) समझने की तुलना में उपयोग करना बहुत आसान है। :)
— गुरन १५'१
11
@ लेफ्टिनेंटबाउटआउट: ठीक है क्योंकि मैं उस बाल-विभाजन के अंतर में नहीं आना चाहता था; मूल पोस्टर के रूप में, कई लोगों को आत्मविश्वास की कमी है जब यह मोनाड्स से निपटने की बात आती है। सरल ऑपरेशन के जारगॉन-लादेन श्रेणी सिद्धांत लक्षण वर्णन आत्मविश्वास और समझ विकसित करने के खिलाफ काम करता है।
— एरिक लिपर्ट
2
तो आपकी सलाह है कि + कुछ बॉयलरप्लेट कोड के Nullसाथ बदलें Nullable? :)
— एरिक डुमिनील
3
@ क्लाउड: आपको मेरा ट्यूटोरियल पढ़ना चाहिए। एक मोनैड एक सामान्य प्रकार है जो कुछ नियमों का पालन करता है और संचालन की एक श्रृंखला को एक साथ बांधने की क्षमता प्रदान करता है, इसलिए इस मामले में, Measurement<T>एक वैचारिक प्रकार है।
— एरिक लिपर्ट
5
@ डबोरसॉस: हालांकि मैं मानता हूं कि स्टेटफुल मोनैड्स मोनड्स को पेश करने का एक अच्छा तरीका है, मैं स्टेट को कैरी करने के बारे में नहीं सोचता क्योंकि यह एक मॉनेड चरित्र है। मैं इस तथ्य के बारे में सोचता हूं कि आप कार्यों के अनुक्रम को एक साथ बांध सकते हैं, सम्मोहक चीज है; राज्य की योग्यता सिर्फ एक कार्यान्वयन विवरण है।
— एरिक लिपर्ट
18

मुझे लगता है कि इस मामले में एक अशक्त वस्तु पैटर्न पर भिन्नता उपयोगी होगी:

public class Measurement
{
    private int value;
    private bool isUnknown = false;
    private bool isMissing = false;

    private Measurement() { }
    public Measurement(int value) { this.value = value; }

    public int Value {
        get {
            if (!isUnknown && !isMissing)
            {
                return this.value;
            }
            throw new SomeException("...");
        }                   
    }

    public static readonly Measurement Unknown = new Measurement
    {
        isUnknown = true
    };

    public static readonly Measurement Missing = new Measurement
    {
        isMissing = true
    };
}

आप इसे एक संरचना में बदल सकते हैं, समतुल्य / GetHashCode / ToString को ओवरराइड कर सकते हैं, इससे या उससे निहित रूपांतरण जोड़ सकते हैं int, और यदि आप NaN जैसा व्यवहार चाहते हैं, तो आप अपने स्वयं के अंकगणित ऑपरेटरों को भी लागू कर सकते हैं ताकि उदा। Measurement.Unknown * 2 == Measurement.Unknown।

उस ने कहा, C # के Nullable<int>सभी लागू करता है, केवल चेतावनी के साथ कि आप विभिन्न प्रकार के बीच अंतर नहीं कर सकते null। मैं एक जावा व्यक्ति नहीं हूं, लेकिन मेरी समझ यह है कि जावा के OptionalIntसमान है, और अन्य भाषाओं में एक Optionalप्रकार का प्रतिनिधित्व करने के लिए अपनी स्वयं की सुविधाएं हैं ।

— मैकीज स्टैकोव्स्की
स्रोत
6
इस पैटर्न के बारे में मैंने जो सबसे आम कार्यान्वयन देखा है, उसमें विरासत शामिल है। दो उप-वर्गों के लिए एक मामला हो सकता है: मिसिंगमर्लमेंट और अनजानपरस्ती। वे मूल मापक वर्ग में विधियों को लागू या ओवरराइड कर सकते हैं। +1
— ग्रेग बर्गहर्ट
2
की बात नहीं है अशक्त वस्तु पैटर्न है कि अवैध मूल्यों पर असफल नहीं, बल्कि कुछ भी नहीं?
— क्रिस वॉहर्ट
2
@ChrisWohlert इस मामले में ऑब्जेक्ट के पास वास्तव में कोई तरीका नहीं है सिवाय इसके कि गटर को छोड़कर Value, जो बिल्कुल असफल होना चाहिए क्योंकि आप Unknownबैक को एक में नहीं बदल सकते int। यदि माप में एक, कहना, SaveToDatabase()विधि होती है, तो एक अच्छा कार्यान्वयन शायद एक लेनदेन नहीं करेगा यदि वर्तमान वस्तु एक अशक्त वस्तु है (या तो सिंगलटन, या विधि ओवरराइड के साथ तुलना के माध्यम से)।
— मैकीज स्टैकोव्स्की
3
@MaciejStachowski हाँ, मैं यह नहीं कह रहा हूँ कि इसे कुछ नहीं करना चाहिए, मैं कह रहा हूँ नल ऑब्जेक्ट पैटर्न एक अच्छा फिट नहीं है। आपका समाधान ठीक हो सकता है, लेकिन मैं इसे नल ऑब्जेक्ट पैटर्न नहीं कहूंगा ।
— बजे क्रिस वोहलर्ट
14

यदि आप शाब्दिक रूप से एक पूर्णांक का उपयोग करते हैं तो केवल एक ही संभव समाधान है। कुछ संभावित मानों को 'मैजिक नंबर' के रूप में उपयोग करें जिसका अर्थ है 'लापता' और 'अज्ञात'

जैसे 2,147,483,647 और 2,147,483,646

यदि आपको केवल 'वास्तविक' माप के लिए इंट की आवश्यकता है, तो एक अधिक जटिल डेटा संरचना बनाएं

class Measurement {
    public bool IsEmpty;
    public bool IsKnown;
    public int Value {
        get {
            if(!IsEmpty && IsKnown) return _value;
            throw new Exception("NaN");
            }
        }
}

महत्वपूर्ण स्पष्टीकरण:

आप वर्ग के लिए ऑपरेटरों को ओवरलोड करके गणित की आवश्यकता को पूरा कर सकते हैं

public static Measurement operator+ (Measurement a, Measurement b) {
    if(a.IsEmpty) { return b; }
    ...etc
}
— ईवान
स्रोत
10
@KakturusOption<Option<Int>>
— Bergi
5
@Bergi आप शायद यह नहीं सोच सकते कि यह दूर से भी स्वीकार्य है ..
— BlueRaja - Danny Pflughoeft
8
@ BlueRaja-DannyPflughoeft वास्तव में यह ओपी विवरण को काफी अच्छी तरह से फिट करता है, जिसमें एक नेस्टेड संरचना भी है। स्वीकार्य बनने के लिए हम एक उचित प्रकार का उपनाम (या "न्यूटाइप") पेश करेंगे - लेकिन इसके type Measurement = Option<Int>परिणामस्वरूप एक पूर्णांक या एक खाली पढ़ा ठीक है, और इसलिए Option<Measurement>एक माप के लिए है जो लिया जा सकता है या नहीं ।
— बेर्गी
7
@ आरपी "NaN के पास इंटेगर"? क्या आप बता सकते हैं कि आपका क्या मतलब है? यह कहना कुछ उल्टा लगता है कि एक संख्या किसी चीज़ के न होने की अवधारणा को "पास" है।
— निक हार्टले
3
@Nic हार्टले हमारे सिस्टम में "स्वाभाविक रूप से" का एक समूह सबसे कम संभव नकारात्मक नकारात्मक पूर्णांक NaN के रूप में आरक्षित किया गया है। हमने उस स्थान का उपयोग विभिन्न कारणों से एन्कोडिंग के लिए किया, क्योंकि उन बाइट्स ने वैध डेटा के अलावा कुछ और का प्रतिनिधित्व किया था। (यह दशकों पहले था और हो सकता है कि मैंने कुछ विवरणों को फ़िज़ किया हो, लेकिन निश्चित रूप से बिट्स का एक सेट था जिसे आप पूर्णांक मान में डाल सकते हैं यदि आप इसे NaN फेंकने की कोशिश करते हैं, तो आप इसके साथ गणित करने की कोशिश कर सकते हैं।
— arp
11

यदि आपके चर फ़्लोटिंग पॉइंट नंबर हैं, तो IEEE754 (फ़्लोटिंग पॉइंट नंबर मानक जो कि अधिकांश आधुनिक प्रोसेसर और भाषाओं द्वारा समर्थित है) में आपकी पीठ है: यह एक छोटी-सी ज्ञात विशेषता है, लेकिन मानक एक को नहीं, बल्कि पूरे परिवार को परिभाषित करता है NaN (नहीं-एक-संख्या) मान, जिसका उपयोग मनमाने ढंग से अनुप्रयोग-परिभाषित अर्थ के लिए किया जा सकता है। उदाहरण के लिए, एकल-सटीक फ़्लोट में, आपके पास 22 निःशुल्क बिट्स होते हैं जिनका उपयोग आप 2 ^ {22} प्रकार के अमान्य मानों के बीच अंतर करने के लिए कर सकते हैं।

आम तौर पर, प्रोग्रामिंग इंटरफेस उनमें से केवल एक को उजागर करते हैं (जैसे, नम्पी का nan); मुझे नहीं पता कि स्पष्ट बिट हेरफेर के अलावा दूसरों को उत्पन्न करने के लिए एक अंतर्निहित तरीका है, लेकिन यह केवल निम्न-स्तरीय दिनचर्या के एक जोड़े को लिखने की बात है। (आपको उन्हें अलग बताने के लिए भी एक की आवश्यकता होगी, क्योंकि डिजाइन द्वारा, a == bहमेशा गलत होता है जब उनमें से एक NaN होता है)।

उनका उपयोग करना अमान्य डेटा को इंगित करने के लिए अपने स्वयं के "मैजिक नंबर" को रोकने से बेहतर है, क्योंकि वे सही तरीके से प्रचार करते हैं और अमान्य-नेस का संकेत देते हैं: उदाहरण के लिए, यदि आप किसी average()फ़ंक्शन का उपयोग करते हैं और जाँच करना भूल जाते हैं, तो आप अपने आप को पैर में गोली मारने का जोखिम नहीं उठाते हैं। आपके विशेष मूल्य।

एकमात्र जोखिम पुस्तकालयों का सही ढंग से समर्थन नहीं करना है, क्योंकि वे काफी अस्पष्ट विशेषता हैं: उदाहरण के लिए, एक क्रमांकन पुस्तकालय उन सभी को समान रूप से 'समतल' कर सकता है nan(जो अधिकांश प्रयोजनों के लिए इसके बराबर दिखता है)।

— फेडेरिको पोलोनी
स्रोत
6

इसे जारी रखते हुए डेविड आर्नो का जवाब है, तो आप OOP में एक साथ भेदभाव संघ की तरह कुछ कर सकते हैं, और इस तरह, स्काला द्वारा प्रदान जावा 8 कार्यात्मक प्रकार, या इस तरह के रूप में एक जावा एफपी पुस्तकालय द्वारा कि के रूप में एक वस्तु कार्यात्मक शैली में Vavr या लोप यह काफी लगता है कुछ लिखने के लिए स्वाभाविक है:

var value = Measurement.of(2);
out.println(value.map(x -> x * 2));

var empty = Measurement.empty();
out.println(empty.map(x -> x * 2));

var unknown = Measurement.unknown();
out.println(unknown.map(x -> x * 2));

मुद्रण

Value(4)
Empty()
Unknown()

( जिस्ट के रूप में पूर्ण कार्यान्वयन ।)

एक एफपी भाषा या पुस्तकालय अन्य उपकरण प्रदान करता है जैसे Try(उर्फ Maybe) (एक ऐसी वस्तु जिसमें या तो एक मूल्य होता है, या एक त्रुटि होती है) और Either(एक ऐसी वस्तु जिसमें या तो सफलता मूल्य या विफलता मूल्य होता है) जिसका उपयोग यहां भी किया जा सकता है।

— डेविड मोल्स
स्रोत
2

आपकी समस्या का आदर्श समाधान इस बात पर टिका हुआ है कि आप एक ज्ञात विफलता और ज्ञात अविश्वसनीय माप के बीच अंतर के बारे में परवाह क्यों करते हैं, और किन डाउनस्ट्रीम प्रक्रियाओं का आप समर्थन करना चाहते हैं। ध्यान दें, इस मामले के लिए 'डाउनस्ट्रीम प्रक्रियाएं' मानव ऑपरेटरों या साथी डेवलपर्स को बाहर नहीं करती हैं।

बस शून्य के "दूसरे स्वाद" के साथ आने से प्रक्रियाओं का डाउनस्ट्रीम सेट व्यवहार के समुचित सेट को प्राप्त करने के लिए पर्याप्त जानकारी नहीं देता है।

यदि आप नीचे की ओर कोड द्वारा किए जा रहे बुरे व्यवहार के स्रोत के बारे में प्रासंगिक धारणाओं के बजाय भरोसा कर रहे हैं, तो मैं उस बुरे आर्किटेक्चर को कहूंगा।

यदि आप एक ज्ञात कारण के बिना असफलता और विफलता के कारण के बीच अंतर करना पर्याप्त जानते हैं, और यह जानकारी भविष्य के व्यवहार को सूचित करने वाली है, तो आपको उस ज्ञान को नीचे की ओर संचारित करना चाहिए, या इसे इनलाइन करना चाहिए।

इससे निपटने के लिए कुछ पैटर्न:

  • सम प्रकार
  • भेदभाव रहित संघ
  • ऑपरेशन के परिणाम और परिणाम के लिए एक क्षेत्र का प्रतिनिधित्व करने वाले एक एनम युक्त ऑब्जेक्ट या संरचनाएं
  • मैजिक स्ट्रिंग्स या मैजिक नंबर जिन्हें सामान्य ऑपरेशन के जरिए हासिल करना असंभव है
  • अपवाद, उन भाषाओं में जिनमें यह प्रयोग मुहावरेदार है
  • यह महसूस करते हुए कि वास्तव में इन दोनों परिदृश्यों के बीच अंतर करने और केवल उपयोग करने का कोई मूल्य नहीं है null
— लोहे का कड़ा
स्रोत
2

अगर मैं एक सुरुचिपूर्ण समाधान के बजाय "कुछ किया जा रहा है" से संबंधित था, तो त्वरित और गंदी हैक केवल स्ट्रिंग्स "अज्ञात", "लापता" और 'मेरे संख्यात्मक मूल्य के स्ट्रिंग प्रतिनिधित्व' का उपयोग करने के लिए होगा, जो तब होगा एक स्ट्रिंग से परिवर्तित और आवश्यकतानुसार उपयोग किया जाता है। इसे लिखने की तुलना में जल्दी लागू किया गया है, और कम से कम कुछ परिस्थितियों में, पूरी तरह से पर्याप्त है। (मैं अब डाउनवोट्स की संख्या पर एक बेटिंग पूल बना रहा हूं ...)

— mickeyf
स्रोत
उल्लेख के लिए "कुछ किया जा रहा है।"
— अलविदा सुश्री Chipps
4
कुछ लोग यह नोट कर सकते हैं कि यह NULL का उपयोग करते हुए अधिकांश समान समस्याओं से ग्रस्त है, अर्थात यह केवल "अज्ञात" और "गायब" चेक की आवश्यकता के लिए NULL जाँच से स्विच करता है, लेकिन भाग्यशाली, मूक डेटा भ्रष्टाचार के लिए रन टाइम क्रैश रखता है केवल संकेतक के रूप में अशुभ जो आप चेक भूल गए। यहां तक ​​कि लापता NULL चेक्स का यह फायदा है कि लिंटर उन्हें पकड़ सकते हैं, लेकिन यह हारता है। यह "अज्ञात" और "लापता" के बीच एक अंतर जोड़ता है, हालांकि, इसलिए यह NULL को
— हरा
2

यदि प्रश्न प्रतीत होता है, तो "मैं एक विधि से जानकारी के दो असंबंधित टुकड़े कैसे लौटाता हूं जो एक एकल इंट लौटाता है? मैं कभी भी अपने रिटर्न मूल्यों की जांच नहीं करना चाहता हूं, और नल खराब हैं, उनका उपयोग न करें।"

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

शुरू में, ऐसा लगता है कि यह अपवाद फेंकने के लिए एक अच्छा मामला हो सकता है।

जब आप कॉलर को कुछ विशेष बताना चाहते हैं जो रिटर्न प्रकार में नहीं है, तो अपवाद अक्सर उपयुक्त प्रणाली हैं: अपवाद केवल त्रुटि राज्यों के लिए नहीं हैं, और आपको यह बताने के लिए बहुत सारे संदर्भ और तर्क वापस करने की अनुमति देते हैं कि आप बस क्यों कर सकते हैं 'आज इंट।

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

लेकिन अपवाद वास्तव में केवल एक वैध समाधान हैं यदि, जैसा कि नाम से पता चलता है, यह एक असाधारण मामला है, न कि व्यवसाय का सामान्य कोर्स।

और एक कोशिश / पकड़ और हैंडलर केवल एक चेक के रूप में बहुत बॉयलरप्लेट है, जो कि पहले स्थान पर आपत्ति की गई थी।

और यदि कॉल करने वाले के पास कोशिश / कैच नहीं है, तो कॉल करने वाले के कॉल करने वाले के पास और इतने पर है।

एक भोला दूसरा पास है "यह एक माप है। नकारात्मक दूरी माप की संभावना नहीं है।" तो कुछ माप Y के लिए, आप बस के लिए const हो सकते हैं

  • -1 = अज्ञात,
  • -2 = मापना असंभव,
  • -3 = उत्तर देने से इनकार कर दिया,
  • -4 = ज्ञात लेकिन गोपनीय,
  • -5 = चंद्रमा चरण के आधार पर बदलता है, तालिका 5 ए देखें,
  • -6 = चार आयामी, शीर्षक में दिए गए माप,
  • -7 = फाइल सिस्टम रीड एरर,
  • -8 = भविष्य के उपयोग के लिए आरक्षित,
  • -9 = वर्ग / घन इसलिए Y X के समान है,
  • -10 = एक मॉनिटर स्क्रीन है इसलिए एक्स, वाई माप का उपयोग नहीं कर रहा है: एक्स का उपयोग स्क्रीन विकर्ण के रूप में करें,
  • -11 = एक रसीद के पीछे माप लिखी और इसे अवैधता में बदल दिया गया, लेकिन मुझे लगता है कि यह या तो 17 साल की थी या 34,
  • -12 = ... आपको विचार मिलता है।

यह वह तरीका है जो बहुत सी पुरानी प्रणालियों में किया जाता है, और यहां तक ​​कि आधुनिक प्रणालियों में भी जहां इंट करने के लिए एक वास्तविक बाधा होती है, और आप इसे किसी प्रकार की संरचना या सनक में नहीं लपेट सकते।

यदि माप नकारात्मक हो सकते हैं, तो आप बस अपने डेटा प्रकार को बड़ा बनाते हैं (जैसे कि लंबे समय तक इंट) और जादू के मान इंट की सीमा से अधिक होते हैं, और आदर्श रूप से कुछ मूल्य के साथ शुरू होते हैं जो डिबगर में स्पष्ट रूप से दिखाई देंगे।

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

हमारे तीसरे प्रयास में, हम उन मामलों को देखते हैं जहां गैर-अंतर मूल्यों के लिए व्यापार का सामान्य कोर्स है। उदाहरण के लिए, यदि इन मानों के संग्रह में कई गैर-पूर्णांक प्रविष्टियाँ हो सकती हैं। इसका मतलब है कि एक अपवाद हैंडलर गलत दृष्टिकोण हो सकता है।

उस मामले में, यह एक संरचना के लिए एक अच्छा मामला दिखता है जो इंट, और तर्क को पारित करता है। फिर, यह औचित्य सिर्फ ऊपर की तरह एक कास्ट हो सकता है, लेकिन दोनों को एक ही इंट में रखने के बजाय, आप उन्हें एक संरचना के अलग-अलग हिस्सों के रूप में संग्रहीत करते हैं। प्रारंभ में, हमारे पास नियम है कि यदि तर्क सेट किया जाता है, तो इंट सेट नहीं किया जाएगा। लेकिन हम अब इस नियम से बंधे नहीं हैं; यदि आवश्यक हो तो हम मान्य संख्याओं के लिए भी युक्तिसंगतता प्रदान कर सकते हैं।

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

यह वह जगह है जहां आपको "शून्य का उपयोग न करें" के पीछे अपने तर्क की जांच करने की आवश्यकता है।

अपवादों की तरह, अशक्त एक असाधारण स्थिति को इंगित करने के लिए है।

यदि कोई कॉलर इस पद्धति को कॉल कर रहा है और संरचना के "औचित्य" भाग को पूरी तरह से अनदेखा कर रहा है, बिना किसी त्रुटि से निपटने के लिए एक संख्या की उम्मीद करता है, और इसे एक शून्य मिलता है, तो यह शून्य को एक संख्या के रूप में संभाल लेगा, और गलत होगा। यदि यह एक जादू की संख्या हो जाता है, यह एक नंबर के रूप में इलाज करेंगे, और गलत होगा। लेकिन अगर यह शून्य हो जाता है, तो यह गिर जाएगा , क्योंकि यह अच्छी तरह से करना चाहिए।

इसलिए हर बार जब आप इस पद्धति को कॉल करते हैं, तो आपको इसके रिटर्न वैल्यू के लिए चेक में रखना होगा, हालांकि आप अमान्य मानों को संभालते हैं, चाहे वह इन-बैंड या बैंड से बाहर हो, कोशिश करें / पकड़ें, एक "तर्क" घटक के लिए संरचना की जांच, इंट की जाँच एक जादू की संख्या के लिए, या एक अशक्त के लिए एक int की जाँच ...

एक आउटपुट के गुणन को संभालने के लिए विकल्प, जिसमें एक अवैध इंट हो सकता है और "मेरा कुत्ता इस माप को खा गया है" जैसा तर्क है, उस संरचना के लिए गुणन ऑपरेटर को ओवरलोड करना है।

... और फिर आपके आवेदन में हर दूसरे ऑपरेटर को अधिभारित करें जो इस डेटा पर लागू हो सकता है।

... और फिर उन सभी तरीकों को अधिभारित करें जो स्याही ले सकते हैं।

... और उन सभी ओवरलोड्स को अभी भी अमान्य ints के लिए जाँचों को शामिल करने की आवश्यकता होगी , ताकि आप इस एक तरीके की वापसी प्रकार का इलाज कर सकें जैसे कि आप इसे कॉल करते समय बिंदु पर हमेशा एक वैध इंट थे।

इसलिए मूल आधार विभिन्न तरीकों से गलत है:

  1. यदि आपके पास अमान्य मान हैं, तो आप उन अमान्य मानों की जाँच करने से बच सकते हैं जहाँ आप मानों को संभाल रहे हैं।
  2. यदि आप एक इंट के अलावा कुछ भी वापस कर रहे हैं, तो आप एक इंट वापस नहीं कर रहे हैं, इसलिए आप इसे इंट की तरह व्यवहार नहीं कर सकते। ऑपरेटर ओवरलोडिंग आपको बहाना देता है, लेकिन यह सिर्फ दिखावा है।
  3. मैजिक नंबर्स (NULL, NAN, Inf ...) के साथ एक इंट अब वास्तव में एक इंट नहीं है, यह एक गरीब व्यक्ति की संरचना है।
  4. नल से बचने से कोड अधिक मजबूत नहीं होगा, यह बस ints के साथ समस्याओं को छिपाएगा, या उन्हें एक जटिल अपवाद-हैंडलिंग संरचना में स्थानांतरित कर देगा।
— देवि मोर्गन
स्रोत
1

मैं आपके प्रश्न के आधार को नहीं समझता, लेकिन यहाँ अंकित मूल्य उत्तर है। गुम या खाली होने के लिए, आप कर सकते हैं math.nan(संख्या नहीं)। आप किसी भी गणितीय कार्य को कर सकते हैं math.nanऔर यह बना रहेगा math.nan।

आप Noneअज्ञात मूल्य के लिए (पायथन के नल) का उपयोग कर सकते हैं । आपको किसी भी तरह से अज्ञात मान में हेरफेर नहीं किया जाना चाहिए, और कुछ भाषाओं (पायथन उनमें से एक नहीं है) के पास विशेष नल ऑपरेटर हैं, ताकि मान नॉनलाइन होने पर ही ऑपरेशन किया जाए, अन्यथा मान अशक्त रहता है।

अन्य भाषाओं में गार्ड क्लॉस (जैसे स्विफ्ट या रूबी) हैं, और रूबी की सशर्त वापसी है।

मैंने इसे कुछ अलग तरीकों से पायथन में हल किया है:

  • एक रैपर डेटा संरचना के साथ, चूंकि संख्यात्मक जानकारी आमतौर पर एक इकाई के बारे में होती है और इसका माप समय होता है। रैपर मैजिक मेथड को ओवरराइड कर सकता है, __mult__ताकि आपके अनजान या मिसिंग मूल्यों के सामने आने पर कोई अपवाद न उठे। Numpy और पांडा में ऐसी क्षमता हो सकती है।
  • एक संतरी मूल्य (जैसे आपका Unknownया -1 / -2) और एक if स्टेटमेंट
  • एक अलग बूलियन ध्वज के साथ
  • एक आलसी डेटा संरचना के साथ- आपका फ़ंक्शन संरचना पर कुछ ऑपरेशन करता है, फिर वह लौटता है, सबसे बाहरी फ़ंक्शन जिसे वास्तविक परिणाम की आवश्यकता होती है वह आलसी डेटा संरचना का मूल्यांकन करता है
  • ऑपरेशन की एक आलसी पाइपलाइन के साथ- पिछले एक के समान, लेकिन यह एक डेटा या डेटाबेस के सेट पर इस्तेमाल किया जा सकता है
— noɥʇʎԀʎzɐɹƆ
स्रोत
1

स्मृति में संग्रहित मूल्य भाषा और कार्यान्वयन विवरण पर कैसे निर्भर करता है। मुझे लगता है कि आपका क्या मतलब है कि ऑब्जेक्ट को प्रोग्रामर से कैसे व्यवहार करना चाहिए। (इस तरह मैंने सवाल पढ़ा है, मुझे बताएं कि क्या मैं गलत हूं।)

आपने पहले ही अपने प्रश्न का उत्तर प्रस्तावित कर दिया है: अपनी स्वयं की कक्षा का उपयोग करें जो किसी भी गणितीय कार्य को स्वीकार करता है और बिना किसी अपवाद के खुद को वापस करता है। आप कहते हैं कि आप ऐसा चाहते हैं क्योंकि आप अशक्त जांच से बचना चाहते हैं।

समाधान 1: अशक्त जांच से बचें

Missingके रूप में प्रतिनिधित्व किया math.nan
Unknownजा सकता हैNone

आप एक से अधिक मूल्य है, तो आप कर सकते हैं filter()केवल मूल्यों है कि नहीं कर रहे हैं पर आपरेशन लागू करने के लिए Unknownया Missing, या जो कुछ भी महत्व देता है आप कार्य के लिए अनदेखा करना चाहते।

मैं एक ऐसे परिदृश्य की कल्पना नहीं कर सकता, जहाँ आपको किसी एकल स्केलर पर काम करने वाले फ़ंक्शन पर नल-चेक की आवश्यकता हो। उस स्थिति में, अशक्त-जाँच को बाध्य करना अच्छा है।

समाधान 2: एक डेकोरेटर का उपयोग करें जो अपवादों को पकड़ता है

इस मामले में, Missingउठा सकता है MissingExceptionऔर Unknownउठा सकता है UnknownExceptionजब इस पर संचालन किया जाता है।

@suppressUnknown(value=Unknown) # if an UnknownException is raised, return this value instead
@suppressMissing(value=Missing)
def sigmoid(value):
    ...

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

जब आप किसी फ़ंक्शन को कॉल करते हैं तो यह उम्मीद नहीं करता है कि मिसिंग को मिसिंग मिल गया है, फ़ंक्शन तुरंत उठाएगा, आपको यह दिखाएगा कि कहां गलती से चुपचाप विफल होने और कॉलिंग श्रृंखला को मिस करने का प्रचार करने के बजाय त्रुटि हुई। वही अज्ञात के लिए चला जाता है।

sigmoidतब भी कॉल कर सकते हैं sin, भले ही यह उम्मीद न करे Missingया Unknown, क्योंकि sigmoidडेकोरेटर अपवाद को पकड़ लेगा।

— noɥʇʎԀʎzɐɹƆ
स्रोत
1
आश्चर्य है कि एक ही प्रश्न के दो उत्तर पोस्ट करने का क्या मतलब है (यह आपका पूर्व उत्तर है , इसके साथ कुछ भी गलत है?)
— gnat
@gnat यह उत्तर तर्क प्रदान करता है कि लेखक को जिस तरह से दिखाया जाना चाहिए वह क्यों नहीं किया जाना चाहिए, और मैं दो उत्तरों को अलग-अलग विचारों के साथ एकीकृत करने की परेशानी से नहीं गुजरना चाहता- दो उत्तरों को लिखना आसान है जिन्हें स्वतंत्र रूप से पढ़ा जा सकता है । मुझे समझ नहीं आता कि आप किसी और के हानिरहित तर्क के बारे में इतना ध्यान क्यों रखते हैं।
— no --zɐɹƆ
0

किसी सर्वर में CPU की संख्या प्राप्त करना मान लें। यदि सर्वर बंद है, या बंद कर दिया गया है, तो यह मान बस अस्तित्व में नहीं है। यह एक माप होगा जिसका कोई मतलब नहीं है (शायद "लापता" / "खाली" सर्वोत्तम शब्द नहीं हैं)। लेकिन मूल्य निरर्थक होने के लिए "ज्ञात" है। यदि सर्वर मौजूद है, लेकिन मूल्य को प्राप्त करने की प्रक्रिया क्रैश हो जाती है, तो इसे मापना वैध है, लेकिन "अज्ञात" मान के परिणामस्वरूप विफल हो जाता है।

ये दोनों ध्वनि की तरह त्रुटि की स्थिति है, इसलिए मैं न्याय करता हूं कि यहां सबसे अच्छा विकल्प केवल get_measurement()इन दोनों को अपवाद के रूप में फेंकना है (जैसे क्रमशः, DataSourceUnavailableExceptionया SpectacularFailureToGetDataException)। फिर, यदि इनमें से कोई भी समस्या होती है, तो डेटा-एकत्रित कोड तुरंत इस पर प्रतिक्रिया कर सकता है (जैसे कि बाद वाले मामले में फिर से कोशिश करके), और get_measurement()केवल intइस मामले में वापस लौटना होगा कि यह डेटा से डेटा को सफलतापूर्वक प्राप्त कर सकता है source - और आप जानते हैं कि intमान्य है।

यदि आपकी स्थिति अपवादों का समर्थन नहीं करती है या उनका अधिक उपयोग नहीं कर सकती है, तो त्रुटि कोड का उपयोग करने के लिए एक अच्छा विकल्प है, शायद एक अलग आउटपुट के माध्यम से लौटा है get_measurement()। यह सी में मुहावरेदार पैटर्न है, जहां वास्तविक आउटपुट एक इनपुट पॉइंटर में संग्रहीत किया जाता है और एक त्रुटि कोड रिटर्न मान के रूप में वापस पारित किया जाता है।

— TheHansinator
स्रोत
0

दिए गए उत्तर ठीक हैं, लेकिन फिर भी मूल्य, खाली और अज्ञात के बीच पदानुक्रमित संबंध को प्रतिबिंबित नहीं करते हैं।

  • उच्चतम अज्ञात आता है ।
  • तब मूल्य का उपयोग करने से पहले पहले खाली को स्पष्ट किया जाना चाहिए।
  • अंतिम के साथ गणना करने के लिए मूल्य आता है ।

अग्ली (इसके असफल अमूर्त के लिए), लेकिन पूरी तरह से परिचालन (जावा में) होगा:

Optional<Optional<Integer>> unknowableValue;

unknowableValue.ifPresent(emptiableValue -> ...);
Optional<Integer> emptiableValue = unknowableValue.orElse(Optional.empty());

emptiableValue.ifPresent(value -> ...);
int value = emptiableValue.orElse(0);

यहां एक अच्छी प्रकार की प्रणाली वाली कार्यात्मक भाषाएं बेहतर हैं।

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

उस मामले में एक इंट वैल्यू एक इंट सप्लायर द्वारा प्राप्त किया जाएगा। एक खाली मान एक अंतर आपूर्तिकर्ता को एक खाली अपवाद फेंक देगा, या खाली (पुनरावर्ती रूप से ऊपर) का मूल्यांकन करेगा। आपका मुख्य सूत्र सभी मूल्यों को जोड़ता है और संभवतः एक खाली (मूल्य / अपवाद) भी लौटाता है। एक अज्ञात मान अपवाद को फेंककर मूल्यांकन को अक्षम कर देगा।

मान संभवत: अवलोकन योग्य होंगे, जैसे कि एक जावा बाध्य संपत्ति, परिवर्तन पर श्रोताओं को सूचित करना।

संक्षेप में: अतिरिक्त राज्यों के खाली और अज्ञात के साथ मूल्यों की आवश्यकता के आवर्ती पैटर्न से संकेत मिलता है कि बाध्य गुण डेटा मॉडल की तरह अधिक फैल शीट बेहतर हो सकती है।

— जोप इगेन
स्रोत
0

हां, कई अलग-अलग NA प्रकारों की अवधारणा कुछ भाषाओं में मौजूद है; और अधिक सांख्यिकीय लोगों में, जहां यह अधिक सार्थक है (अर्थात, मिसिंग-एट-रैंडम, मिसिंग-कम्प्लीटली-एट-रैंडम, मिसिंग-नॉट-एट-रैंडम के बीच बहुत बड़ा अंतर )।

  • यदि हम केवल विजेट की लंबाई माप रहे हैं, तो यह 'सेंसर विफलता' या 'पावर कट' या 'नेटवर्क विफलता' के बीच अंतर करना महत्वपूर्ण नहीं है (हालांकि 'संख्यात्मक अतिप्रवाह' से जानकारी मिलती है)

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

  • वहाँ भी मामला है जहाँ हमारे पास एक प्रविष्टि ("कई प्रतिरूपण") के लिए कई NA चर हैं। उदाहरण: यदि मुझे किसी व्यक्ति की आयु, ज़िपकोड, शिक्षा स्तर या आय का कोई पता नहीं है, तो उनकी आय को लागू करना कठिन है।

जैसा कि आप सामान्य-प्रयोजन की भाषाओं में विभिन्न NA प्रकारों का प्रतिनिधित्व करते हैं जो उनका समर्थन नहीं करते हैं, आम तौर पर लोग फ्लोटिंग-पॉइंट-NaN (पूर्णांक परिवर्तित करने की आवश्यकता होती है), एनम या प्रहरी (जैसे 999 या -1000) जैसी चीजों को पूर्णांक के लिए हैक करते हैं श्रेणीबद्ध मूल्य। आमतौर पर बहुत साफ जवाब नहीं है, क्षमा करें।

— एसएमसीआई
स्रोत
0

आर में बिल्ड-इन मिसिंग वैल्यू सपोर्ट है। https://medium.com/coinmonks/dealing-with-missing-data-using-r-3ae428da2d17

संपादित करें: क्योंकि मुझे नीचा दिखाया गया था, मैं थोड़ा समझाने जा रहा हूं।

यदि आप आँकड़ों से निपटने जा रहे हैं, तो मैं आपको R जैसी सांख्यिकी भाषा का उपयोग करने की सलाह देता हूँ क्योंकि R, सांख्यिकीविदों के लिए R द्वारा लिखा गया है। मूल्यों का गुम होना इतना बड़ा विषय है कि वे आपको पूरा सेमेस्टर पढ़ाते हैं। और केवल गुम मूल्यों के बारे में बड़ी किताबें हैं।

हालाँकि, आप मिसिंग डेटा को चिह्नित करना चाहते हैं, जैसे डॉट या "मिसिंग" या जो भी हो। आर में आप परिभाषित कर सकते हैं कि आपके लापता होने का क्या मतलब है। आपको उन्हें परिवर्तित करने की आवश्यकता नहीं है।

लापता मान को परिभाषित करने का सामान्य तरीका उन्हें चिह्नित करना है NA।

x <- c(1, 2, NA, 4, "")

तब आप देख सकते हैं कि क्या मूल्य गायब हैं;

is.na(x)

और फिर परिणाम होगा;

FALSE FALSE  TRUE FALSE FALSE

जैसा कि आप देख सकते हैं ""गायब नहीं है। आप ""अज्ञात के रूप में धमकी दे सकते हैं । और NAगायब है।

— इल्हान
स्रोत
@ हाय, क्या अन्य कार्यात्मक भाषाओं के लापता मूल्यों का समर्थन करते हैं? यहां तक ​​कि अगर वे लापता मानों का समर्थन करते हैं, तो मुझे यकीन है कि आप उन्हें केवल एक लाइन के कोड में सांख्यिकीय तरीकों से नहीं भर सकते।
— इल्हान
-1

क्या कोई कारण है कि *ऑपरेटर की कार्यक्षमता बदले नहीं जा सकती है?

अधिकांश उत्तरों में किसी प्रकार का लुकअप मान शामिल होता है, लेकिन इस मामले में गणितीय ऑपरेटर को संशोधित करना आसान हो सकता है।

तब आप अपनी पूरी परियोजना में समान empty()/ unknown()कार्यक्षमता रख सकेंगे ।

— एडवर्ड
स्रोत
4
इसका मतलब है कि आपको
— पाइप
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.