float('nan')ප්‍රති results ල නාන් (අංකයක් නොවේ). නමුත් මම එය පරීක්ෂා කරන්නේ කෙසේද? ඉතා පහසු විය යුතුය, නමුත් මට එය සොයාගත නොහැක.

math.isnan (x)

TrueX යනු NaN (අංකයක් නොවේ) සහ Falseවෙනත් ආකාරයකින් ආපසු යන්න .

>>> import math
>>> x = float('nan')
>>> math.isnan(x)
True

NaN සඳහා පරීක්ෂා කිරීම සඳහා සුපුරුදු ක්‍රමය නම් එය තමාටම සමාන දැයි බැලීමයි:

def isNaN(num):
    return num != num

numpy.isnan(number)එය තිබේද නැද්ද යන්න ඔබට කියයි NaN.

විචල්‍යයක් පරීක්ෂා කළ හැකි ක්‍රම තුනක් මෙන්න “NaN” හෝ නොවේ.

import pandas as pd
import numpy as np
import math

#For single variable all three libraries return single boolean
x1 = float("nan")

print(f"It's pd.isna  : {pd.isna(x1)}")
print(f"It's np.isnan  : {np.isnan(x1)}")
print(f"It's math.isnan : {math.isnan(x1)}")

ප්‍රතිදානය

It's pd.isna  : True
It's np.isnan  : True
It's math.isnan  : True

මෙන්න වැඩ කරන පිළිතුරක්:

• IEEE 754 ප්‍රමිතියට අදාළ NaN ක්‍රියාත්මක කිරීම්
  • එනම්: පිඹුරා ගේ නන්: float('nan'), numpy.nan...
• වෙනත් ඕනෑම වස්තුවක්: නූල් හෝ වෙනත් (හමු වුවහොත් ව්‍යතිරේකයන් මතු නොකරයි)

ප්‍රමිතිය අනුව ක්‍රියාවට නංවන ලද NaN එකක්, අසමානතාවය තමා හා සැසඳීමේදී සත්‍යය ආපසු ලබා දිය යුතු එකම අගයයි:

def is_nan(x):
    return (x != x)

සහ උදාහරණ කිහිපයක්:

import numpy as np
values = [float('nan'), np.nan, 55, "string", lambda x : x]
for value in values:
    print(f"{repr(value):<8} : {is_nan(value)}")

ප්‍රතිදානය:

nan      : True
nan      : True
55       : False
'string' : False
<function <lambda> at 0x000000000927BF28> : False

මම ඇත්තටම මේකට දිව්වා, නමුත් මට නම් එය නන්, -ඉන්ෆ් හෝ ඉන්ෆ්. මම දැන් පාවිච්චි කළා

if float('-inf') < float(num) < float('inf'):

මෙය සංඛ්‍යා සඳහා සත්‍ය වන අතර, නන් සහ ඉන්ෆ් යන දෙකටම අසත්‍ය වන අතර, නූල් හෝ වෙනත් වර්ග වැනි දේ සඳහා ව්‍යතිරේකයක් මතු කරනු ඇත (එය බොහෝ විට හොඳ දෙයක් විය හැකිය). ගණිත හෝ අංකී වැනි කිසිදු පුස්තකාලයක් ආනයනය කිරීම මෙයට අවශ්‍ය නොවේ (අංකී ඉතා විශාල බැවින් එය සම්පාදනය කරන ලද යෙදුමක ප්‍රමාණය මෙන් දෙගුණයක් වේ).

math.isnan ()

හෝ අංකය තමාටම සංසන්දනය කරන්න. ! = නන්, වෙනත් ආකාරයකින් සෑම විටම නන් වේ (එය උදා නම් වේ ගණනාවක්) ඇති සැසැඳුම සාර්ථක යුතුය.

ඔබ <2.6 හි සිරවී සිටින්නේ නම් තවත් ක්‍රමයක් නම්, ඔබට අමිහිරි බවක් නොමැති අතර ඔබට IEEE 754 සහය නොමැත:

def isNaN(x):
    return str(x) == str(1e400*0)

හොඳයි, මම මෙම තනතුරට ඇතුළු වූයේ, මට ශ්‍රිතයේ යම් යම් ගැටලු ඇති බැවිනි:

math.isnan()

ඔබ මෙම කේතය ක්‍රියාත්මක කිරීමේදී ගැටළු තිබේ:

a = "hello"
math.isnan(a)

එය ව්යතිරේකය මතු කරයි. ඒ සඳහා මගේ විසඳුම වන්නේ තවත් පරීක්‍ෂණයක් කිරීමයි:

def is_nan(x):
    return isinstance(x, float) and math.isnan(x)

පයිතන් <2.6 සමඟ මම අවසන් කළෙමි

def isNaN(x):
    return str(float(x)).lower() == 'nan'

මෙය මට සෝලාරිස් 5.9 පෙට්ටියක පයිතන් 2.5.1 සහ උබුන්ටු 10 හි පයිතන් 2.6.5 සමඟ වැඩ කරයි

මම එවන වෙබ්-සේවයෙන් දත්ත ලබාගන්නා මා NaNවැලක් ලෙස 'Nan'. නමුත් මගේ දත්තවල වෙනත් ආකාරයේ නූල් ද තිබිය හැකිය, එබැවින් සරල float(value)කෙනෙකුට ව්‍යතිරේකයක් විසි කළ හැකිය. පිළිගත් පිළිතුරේ පහත ප්‍රභේදය මම භාවිතා කළෙමි:

def isnan(value):
  try:
      import math
      return math.isnan(float(value))
  except:
      return False

අවශ්‍යතාවය:

isnan('hello') == False
isnan('NaN') == True
isnan(100) == False
isnan(float('nan')) = True

එය තමාටම සමාන දැයි පරීක්ෂා කිරීම පෙනේ

x!=x

වේගවත්ම වේ.

import pandas as pd 
import numpy as np 
import math 

x = float('nan')

%timeit x!=x                                                                                                                                                                                                                        
44.8 ns ± 0.152 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

%timeit math.isnan(x)                                                                                                                                                                                                               
94.2 ns ± 0.955 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

%timeit pd.isna(x) 
281 ns ± 5.48 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%timeit np.isnan(x)                                                                                                                                                                                                                 
1.38 µs ± 15.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

විචල්‍යය NaN හෝ කිසිවක් නොවේදැයි පැවසීමට සියලු ක්‍රම:

කිසිවක් වර්ග නැත

In [1]: from numpy import math

In [2]: a = None
In [3]: not a
Out[3]: True

In [4]: len(a or ()) == 0
Out[4]: True

In [5]: a == None
Out[5]: True

In [6]: a is None
Out[6]: True

In [7]: a != a
Out[7]: False

In [9]: math.isnan(a)
Traceback (most recent call last):
  File "<ipython-input-9-6d4d8c26d370>", line 1, in <module>
    math.isnan(a)
TypeError: a float is required

In [10]: len(a) == 0
Traceback (most recent call last):
  File "<ipython-input-10-65b72372873e>", line 1, in <module>
    len(a) == 0
TypeError: object of type 'NoneType' has no len()

NaN වර්ගය

In [11]: b = float('nan')
In [12]: b
Out[12]: nan

In [13]: not b
Out[13]: False

In [14]: b != b
Out[14]: True

In [15]: math.isnan(b)
Out[15]: True

මිශ්‍ර දත්ත වර්ග ලැයිස්තුවකින් NaN (පාවෙන) අයිතම (ය) ඉවත් කරන්නේ කෙසේද?

ඔබට නැවත සැකසිය හැකි මිශ්‍ර වර්ග තිබේ නම්, අංකයක් භාවිතා නොකරන විසඳුමක් මෙන්න:

from math import isnan

Z = ['a','b', float('NaN'), 'd', float('1.1024')]

[x for x in Z if not (
                      type(x) == float # let's drop all float values…
                      and isnan(x) # … but only if they are nan
                      )]

['a', 'b', 'd', 1.1024]

කෙටි පරිපථ ඇගයීම යනු දකුණු පස තක්සේරු කිරීමකින් තොරව ඉක්මණින් තක්සේරු කරන isnanපරිදි 'පාවෙන' වර්ගයේ නොවන අගයන් වෙත කැඳවනු නොලැබේ .False and (…)False

පයිතන් 3.6 හි x math.isnan (x) සහ np.isnan (x) යන නූල් අගයක් පරීක්ෂා කිරීම දෝෂයක් මතු කරයි. එබැවින් ලබා දී ඇති අගය NaN ද නැද්ද යන්න පරීක්ෂා කර බැලිය නොහැක. පහත දැක්වෙන්නේ මෙම ගැටළුව විසඳන බවයි

if str(x)=='nan' and type(x)!='str':
    print ('NaN')
else:
    print ('non NaN')

වර්ගයේ පාවෙන නන් සඳහා

>>> import pandas as pd
>>> value = float(nan)
>>> type(value)
>>> <class 'float'>
>>> pd.isnull(value)
True
>>>
>>> value = 'nan'
>>> type(value)
>>> <class 'str'>
>>> pd.isnull(value)
False

පැන්ඩා වල නූල් සඳහා pd.isnull ගන්න:

if not pd.isnull(atext):
  for word in nltk.word_tokenize(atext):

එන්එල්ටීකේ සඳහා විශේෂාංග නිස්සාරණය ලෙස ක්‍රියා කිරීම

def act_features(atext):
features = {}
if not pd.isnull(atext):
  for word in nltk.word_tokenize(atext):
    if word not in default_stopwords:
      features['cont({})'.format(word.lower())]=True
return features