बिना चर के अजगर में एक चर NaN असाइन करना

103

अधिकांश भाषाओं में एक NaN स्थिरांक होता है जिसका उपयोग आप वैरिएबल मान NaN असाइन करने के लिए कर सकते हैं। क्या अजगर सुन्न के बिना ऐसा कर सकता है?

python constants nan

— ज़ेलिन्का
स्रोत

1

सी, सी ++, जावा, सी #, ओसमल, इसकी बहुत सारी भाषाओं का एक हिस्सा है।

— ज़ेलिंका

2

NaN, C में, है NAN; यह math.hC99 के रूप में एक निरंतर परिभाषित है । (मुझे लगता है कि भाषा के सबसे हाल ही में मानकीकृत संस्करण को उस भाषा के रूप में कॉल करना उचित है। इस प्रकार "C" C11 है।) (देखें stackoverflow.com/questions/1923837/how-to-use-nan-and-inf-in -सी ); C ++, यह NANअच्छी तरह से, वहाँ भी है के रूप में nan(), nanf()है, और nanl(), हालांकि मैं थोड़ा कम वे क्या करते हैं के रूप में कुछ कर रहा हूँ। double.NaNजावा में, Double.NaNC #…

— थानटोस

169

हाँ - का उपयोग करें math.nan।

>>> from math import nan
>>> print(nan)
nan
>>> print(nan + 2)
nan
>>> nan == nan
False
>>> import math
>>> math.isnan(nan)
True

पायथन 3.5 से पहले, कोई भी उपयोग कर सकता था float("nan")(केस असंवेदनशील)।

ध्यान दें कि यह देखने के लिए कि क्या दो चीजें जो NaN एक दूसरे के बराबर हैं, हमेशा झूठे वापस आएंगी। यह भाग में है क्योंकि दो चीजें जो "एक नंबर नहीं हैं" (सख्ती से बोलना) एक दूसरे के बराबर नहीं हो सकती हैं - देखें कि IEEE754 NaN मानों के लिए झूठे लौटने वाले सभी तुलनाओं के लिए तर्क क्या है? अधिक जानकारी और जानकारी के लिए।

इसके बजाय, उपयोग करें math.isnan(...)यदि आपको यह निर्धारित करने की आवश्यकता है कि क्या मूल्य NaN है या नहीं।

इसके अलावा, के सटीक अर्थ विज्ञान ==NaN मूल्य पर आपरेशन सूक्ष्म मुद्दों जब इस तरह के रूप कंटेनर प्रकार के अंदर दुकान NaN करने की कोशिश कर कारण हो सकता है listया dict(या जब कस्टम कंटेनर प्रकार का उपयोग)। अधिक विवरण के लिए एक कंटेनर में NaN उपस्थिति के लिए जाँच करना देखें ।

आप पायथन के दशमलव मॉड्यूल का उपयोग करके NaN नंबर भी बना सकते हैं :

>>> from decimal import Decimal
>>> b = Decimal('nan')
>>> print(b)
NaN
>>> print(repr(b))
Decimal('NaN')
>>>
>>> Decimal(float('nan'))
Decimal('NaN')
>>> 
>>> import math
>>> math.isnan(b)
True

math.isnan(...) दशमलव वस्तुओं के साथ भी काम करेगा।

हालाँकि, आप पायथन के अंशों में NaN संख्याओं का निर्माण नहीं कर सकते हैं :

>>> from fractions import Fraction
>>> Fraction('nan')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Python35\lib\fractions.py", line 146, in __new__
    numerator)
ValueError: Invalid literal for Fraction: 'nan'
>>>
>>> Fraction(float('nan'))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Python35\lib\fractions.py", line 130, in __new__
    value = Fraction.from_float(numerator)
  File "C:\Python35\lib\fractions.py", line 214, in from_float
    raise ValueError("Cannot convert %r to %s." % (f, cls.__name__))
ValueError: Cannot convert nan to Fraction.

संयोग से, आप भी कर सकते हैं float('Inf'), Decimal('Inf')या math.inf(3.5+) अनंत संख्या आवंटित करने के लिए। (और देखें math.isinf(...))

हालांकि , NaN की तरह करना Fraction('Inf')या Fraction(float('inf'))अनुमति नहीं है और एक अपवाद को फेंक देगा।

यदि आप यह जांचना चाहते हैं कि कोई संख्या न तो NaN है और न ही अनंत तरीके से जांचने का एक त्वरित और आसान तरीका है, तो आप math.isfinite(...)पायथन 3.2+ का उपयोग कर सकते हैं ।

यदि आप जटिल संख्याओं के साथ समान जांच करना चाहते हैं, तो cmathमॉड्यूल में मॉड्यूल के समान फ़ंक्शन और स्थिरांक होते हैं math:

cmath.isnan(...)
cmath.isinf(...)
cmath.isfinite(...) (पायथन 3.2+)
cmath.nan(अजगर 3.6+ के बराबर complex(float('nan'), 0.0))
cmath.nanj(अजगर 3.6+ के बराबर complex(0.0, float('nan')))
cmath.inf(अजगर 3.6+ के बराबर complex(float('inf'), 0.0))
cmath.infj(अजगर 3.6+ के बराबर complex(0.0, float('inf')))

— Michael0x2a
स्रोत

2

ध्यान दें कि फ्लोट ('नेन) का उपयोग np.nan की तुलना में 3x धीमा है, और नैन = फ्लोट (' नेन ') को असाइन करने की तुलना में लगभग 6.5 गुना धीमा है और फिर निम्नलिखित सभी असाइनमेंट्स के लिए वेरिएबल' नैन 'का उपयोग कर (जैसा कि अबर्नट में सुझाया गया है) जवाब)।

— डैनियल गोल्डफर्ब

18

nan = float('nan')

और अब आपके पास निरंतर है nan,।

आप इसी प्रकार दशमलव के लिए NaN मान बना सकते हैं।

dnan = Decimal('nan')

— abarnert
स्रोत

यह कई नैनो असाइनमेंट के लिए सबसे कुशल उत्तर है: अर्थात, फ्लोट ('नेन') का उपयोग केवल एक बार करें, और फिर सभी शेष असाइनमेंट के लिए असाइन किए गए स्थिरांक का उपयोग करें। हालाँकि यदि आप केवल कुल के एक या दो असाइनमेंट कर रहे हैं, तो numpy.nan का उपयोग करना सबसे तेज़ है।

— डैनियल गोल्डफर्ब

7

उपयोग करें float("nan"):

>>> float("nan")
nan

— orlp
स्रोत

6

आप float('nan')NaN प्राप्त करने के लिए कर सकते हैं ।

— BrenBarn
स्रोत

6

आप NaN को "inf - inf" से प्राप्त कर सकते हैं, और आप 2e308 से अधिक संख्या से "inf" प्राप्त कर सकते हैं, इसलिए, मैं आमतौर पर उपयोग करता हूं:

>>> inf = 9e999
>>> inf
inf
>>> inf - inf
nan

— कनिष्ठ पोलगोतो
स्रोत

3

यह उत्तर अनुचित रूप से अस्वीकार कर दिया गया। मैं .txt फ़ाइलों में बहुत से छोटे पार्सिंग परीक्षण लिख रहा हूँ और अपेक्षित आउटपुट भाग प्राप्त करने के लिए ast.literal_eval का उपयोग कर रहा हूँ। वहां फ्लोट ('नान') को कॉल करना असंभव है, और यह जवाब मेरे लिए मददगार था।

— विटालिक वेरोवोडोव

0

Inf और -inf उत्पन्न करने के लिए एक अधिक सुसंगत (और कम अपारदर्शी) तरीका फिर से फ्लोट () का उपयोग करना है:

>> positive_inf = float('inf')
>> positive_inf
inf
>> negative_inf = float('-inf')
>> negative_inf
-inf

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

import sys
sys.float_info
sys.float_info(max=1.7976931348623157e+308,
               max_exp=1024, max_10_exp=308,
               min=2.2250738585072014e-308, min_exp=-1021,
               min_10_exp=-307, dig=15, mant_dig=53,
               epsilon=2.220446049250313e-16, radix=2, rounds=1)

— user3685621
स्रोत