ඔබට කළ හැකි හිස් නූල් විචල්‍යයක් වැනි දෙයක් පයිතන්ට තිබේද:

if myString == string.empty:

කෙසේ වෙතත්, හිස් නූල් අගයන් පරික්ෂා කිරීමට වඩාත්ම අලංකාර ක්‍රමය කුමක්ද? ""හිස් නූලක් එතරම් හොඳ නොවන බව පරීක්ෂා කිරීම සඳහා සෑම අවස්ථාවකදීම දෘඩ කේතීකරණයක් මට පෙනේ .

හිස් නූල් "ව්‍යාජ" වන අතර එයින් අදහස් කරන්නේ ඒවා බූලියන් සන්දර්භයක් තුළ අසත්‍ය ලෙස සලකනු ලබන බැවින් ඔබට මෙය කළ හැකිය:

if not myString:

ඔබේ විචල්‍යය නූලක් බව ඔබ දන්නේ නම් මෙය වඩාත් සුදුසු ක්‍රමයයි. ඔබේ විචල්‍යය වෙනත් වර්ගයක් විය හැකි නම් ඔබ භාවිතා කළ යුතුය myString == "". බූලියන් සන්දර්භය තුළ අසත්‍ය වන වෙනත් අගයන් සඳහා සත්‍ය අගය පරීක්ෂා කිරීම පිළිබඳ ප්‍රලේඛනය බලන්න .

සිට පී 8 ද, "ක්රමලේඛ නිර්දේශ" කොටස :

අනුක්‍රම සඳහා, (නූල්, ලැයිස්තු, ටුපල්), හිස් අනුක්‍රම අසත්‍යය යන කාරණය භාවිතා කරන්න.

එබැවින් ඔබ භාවිතා කළ යුත්තේ:

if not some_string:

හෝ:

if some_string:

පැහැදිලි කිරීම සඳහා, අනුපිළිවෙල හිස් හෝ නැතිනම් බූලියන් සන්දර්භයකට හෝ ඇගයීමට ලක් කෙරේ . ඔවුන් කරන්නේ සමාන නොවන කිරීමට හෝ .FalseTrueFalseTrue

වඩාත්ම අලංකාර ක්‍රමය වනුයේ එහි සත්‍ය හෝ ව්‍යාජද යන්න සරලව පරීක්ෂා කිරීමයි, උදා:

if not my_string:

කෙසේ වෙතත්, ඔබට සුදු අවකාශය ඉවත් කිරීමට අවශ්‍ය විය හැකිය:

 >>> bool("")
 False
 >>> bool("   ")
 True
 >>> bool("   ".strip())
 False

කෙසේවෙතත්, මෙම නූල යම් ආකාරයක වලංගු භාවයක් පසු කර ඇති බවත්, මේ ආකාරයෙන් පරීක්ෂා කළ හැකි නූලක් බවත් ඔබ නොදන්නේ නම් මිස, ඔබ මේ ගැන තව ටිකක් පැහැදිලි විය යුතුය.

ඉවත් කිරීමට පෙර මම නොහොබිනාකම පරීක්ෂා කරමි. එසේම, හිස් නූල් අසත්‍ය (හෝ ව්‍යාජ) යන කාරණය මම භාවිතා කරමි. මෙම ප්‍රවේශය Apache හි StringUtils.isBlank හෝ Guava's Strings.isNullOrEmpty ට සමාන වේ

නූලක් කිසිවක් නැතිනම් හිස් හෝ හිස් දැයි පරීක්ෂා කිරීමට මා භාවිතා කරන්නේ මෙයයි:

def isBlank (myString):
    if myString and myString.strip():
        #myString is not None AND myString is not empty or blank
        return False
    #myString is None OR myString is empty or blank
    return True

තවද, නූලක් කිසිවක් නොමැතිදැයි පරීක්ෂා කිරීමට හරියටම ප්‍රතිවිරුද්ධ දෙය NOR හිස් NOR හිස්:

def isNotBlank (myString):
    if myString and myString.strip():
        #myString is not None AND myString is not empty or blank
        return True
    #myString is None OR myString is empty or blank
    return False

ඉහත කේතයේ වඩාත් සංක්ෂිප්ත ආකාර:

def isBlank (myString):
    return not (myString and myString.strip())

def isNotBlank (myString):
    return bool(myString and myString.strip())

මම වරක් බාර්ටෙක්ගේ පිළිතුරට සමාන යමක් ලියා ඇති අතර ජාවාස්ක්‍රිප්ට් දේවානුභාවයෙන්:

def is_not_blank(s):
    return bool(s and s.strip())

පරීක්ෂණය:

print is_not_blank("")    # False
print is_not_blank("   ") # False
print is_not_blank("ok")  # True
print is_not_blank(None)  # False

මෙය කළ හැකි එකම ස්ථිර ක්‍රමය පහත දැක්වේ:

if "".__eq__(myString):

අනෙක් සියලුම විසඳුම් චෙක්පත අසමත් විය හැකි ගැටළු සහ අද්දර අවස්ථා ඇත.

len(myString)==0myStringපන්තියක වස්තුවක් උරුම වී strඒවා ඉක්මවා ගියහොත් අසමත් විය හැකිය__len__() ක්‍රමයෙන් .

සමානව myString == ""හා myString.__eq__("")නම් අසමත් හැකි myStringයටපත් කිරීම් __eq__()සහ__ne__() .

කිසියම් හේතුවක් නිසා ඉක්මවා "" == myStringගියහොත් myStringරැවටෙනු __eq__()ඇත.

myString is ""සහ "" is myStringසමාන වේ. myStringඇත්ත වශයෙන්ම නූලක් නොව නූලක් නම් එය දෙකම අසාර්ථක වනු ඇත (දෙකම නැවත පැමිණේ False). එසේම, ඒවා අනන්‍යතා පරීක්‍ෂා කර ඇති හෙයින්, ඔවුන් වැඩ කිරීමට ඇති එකම හේතුව වන්නේ පයිතන් නූල් තටාකය භාවිතා කරන හෙයිනි (එය නූල් ඉන්ටර්නෙට්මන්ට් ලෙසද හැඳින්වේ) එය නූල් එකක භාවිතා කරන්නේ නම් එම අවස්ථාවම භාවිතා කරයි (මෙහි බලන්න: නූල් සංසන්දනය කරන්නේ ඇයි? ' = 'හෝ' යනු 'සමහර විට වෙනස් ප්‍රති result ලයක් ලබා දෙයිද? ). හා ""CPython දී ආරම්භයේ සිට සිර ඇත

අනන්‍යතා පරීක්‍ෂණයේ ඇති විශාලතම ගැටළුව නම්, නූල් සීමාව යනු (මට සොයාගත හැකි තාක් දුරට) කුමන නූල් අන්තර්ග්‍රහණය කර ඇත්ද යන්න ප්‍රමිතිගත නොවීමයි. එයින් අදහස් වන්නේ න්‍යායාත්මකව ""සීමාවාසිකව අවශ්‍ය නොවන අතර එය ක්‍රියාත්මක කිරීම මත රඳා පවතී.

සැබවින්ම රැවටීමට නොහැකි එකම ක්‍රමය මෙය මුලදී සඳහන් කළ ක්‍රමයයි : "".__eq__(myString). මෙය __eq__()හිස් නූලේ ක්‍රමය පැහැදිලිවම හඳුන්වන බැවින්, MyString හි කිසිදු ක්‍රමයක් ඉක්මවා යාමෙන් එය රැවටිය නොහැකි අතර උප පංති සමඟ ly න ලෙස ක්‍රියා කරයිstr .

වස්තුව එය ඉක්මවා ගියහොත් නූලක ව්‍යාජත්වය මත රඳා සිටීම ක්‍රියා නොකරනු ඇත __bool__() ක්‍රමවේදය .

මෙය න්‍යායාත්මක කාර්යයක් පමණක් නොව සැබෑ භාවිතයට අදාළ විය හැකිය. මන්දයත් රාමු සහ පුස්තකාල උප පංති strපෙර සහ භාවිතා කරන ආකාරය මා දැක ඇති හෙයිනි.myString is "" වැරදි ප්‍රතිදානයක් ලැබෙනු ඇත.

එසේම, භාවිතා කරමින් නූල් සංසන්දනය කිරීම is පොදුවේ කරන ඉතා නපුරු උගුලකි, මන්ද එය සමහර විට නිවැරදිව ක්‍රියා කරනු ඇත, නමුත් වෙනත් වේලාවක නොවේ, නූල් සංචලනය ඉතා අමුතු නීති රීති අනුගමනය කරන බැවින්.

එයින් කියැවෙන්නේ බොහෝ අවස්ථාවන්හි දී සඳහන් කළ විසඳුම් සියල්ලම නිවැරදිව ක්‍රියාත්මක වනු ඇති බවයි. මෙය තනතුර බොහෝ දුරට අධ්‍යයන කටයුතු වේ.

හිස් හෝ හිස් නූලක් පරීක්ෂා කරන්න (කෙටි මාර්ගය):

if myString.strip():
    print("it's not an empty or blank string")
else:
    print("it's an empty or blank string")

ඔබට හිස් හා ශුන්‍ය නූල් අතර වෙනස හඳුනා ගැනීමට අවශ්‍ය නම්, භාවිතා කිරීමට මම යෝජනා කරමි, එසේ නොමැතිනම් if len(string), if stringඅනෙක් අය පැවසූ පරිදි සරලව භාවිතා කිරීමට මම යෝජනා කරමි . හිස් අවකාශයෙන් පිරී ඇති නූල් පිළිබඳ අවවාදය තවමත් අදාළ වේ, එබැවින් අමතක නොකරන්න strip.

if stringname:නූල falseහිස් වූ විට a ලබා දෙයි . මම හිතන්නේ එය මීට වඩා සරල විය නොහැක.

හිස් නූලක් එතරම් හොඳ නොවන බව පරීක්ෂා කිරීම සඳහා සෑම අවස්ථාවකදීම මම දෘ c කේතකරණය (sic) සොයා ගතිමි.

කේත ප්‍රවේශය පිරිසිදු කරන්න

මෙය කිරීම: foo == ""ඉතා නරක පුරුද්දකි. ""ඉන්ද්‍රජාලික අගයක්. ඔබ කිසි විටෙකත් ඉන්ද්‍රජාලික අගයන්ට එරෙහිව පරීක්ෂා නොකළ යුතුය (වඩාත් සාමාන්‍යයෙන් ඉන්ද්‍රජාලික සංඛ්‍යා ලෙස හැඳින්වේ )

ඔබ කළ යුත්තේ විස්තරාත්මක විචල්‍ය නාමයකට සංසන්දනය කිරීමයි.

විස්තරාත්මක විචල්ය නම්

"හිස්_ ස්ට්‍රිං" යනු විස්තරාත්මක විචල්‍ය නාමයක් යැයි කෙනෙකුට සිතිය හැකිය. එය එසේ නොවේ .

ඔබ ගොස් කිරීමට පෙර empty_string = "" සංසන්දනය කිරීමට විශාල විචල්‍ය නාමයක් ඇතැයි සිතීමට . “විස්තරාත්මක විචල්‍ය නාමය” යන්නෙහි තේරුම මෙය නොවේ.

හොඳ විස්තරාත්මක විචල්‍ය නාමයක් එහි සන්දර්භය මත පදනම් වේ. ඔබ හිස් අගයක් දේ ගැන හිතන්න ඇති වේ .

• එය පැමිණෙන්නේ කොහෙන්ද?
• ඇයි එතන.
• ඔබ ඒ සඳහා පරීක්ෂා කළ යුත්තේ ඇයි?

සරල පෝරම ක්ෂේත්‍ර උදාහරණය

ඔබ ගොඩනඟන්නේ පරිශීලකයෙකුට වටිනාකම් ඇතුළත් කළ හැකි පෝරමයක්. පරිශීලකයා යමක් ලියා ඇත්දැයි පරීක්ෂා කිරීමට ඔබට අවශ්‍යය.

හොඳ විචල්‍ය නමක් විය හැකිය not_filled_in

මෙමඟින් කේතය ඉතා පහසුවෙන් කියවිය හැකිය

if formfields.name == not_filled_in:
    raise ValueError("We need your name")

සම්පූර්ණ CSV විග්‍රහ කිරීමේ උදාහරණය

ඔබ CSV ලිපිගොනු විග්‍රහ කරමින් සිටින අතර හිස් නූල විග්‍රහ කිරීමට අවශ්‍යය None

(CSV මුළුමනින්ම පෙළ මත පදනම් වූ බැවින්, Noneපෙර නියම කළ වචන භාවිතා නොකර එය නියෝජනය කළ නොහැක )

හොඳ විචල්‍ය නමක් විය හැකිය CSV_NONE

මෙමඟින් ඔබට නව CSV ගොනුවක් තිබේ නම් එය වෙනස් කිරීමට හා අනුවර්තනය වීමට පහසු Noneවේ""

if csvfield == CSV_NONE:
    csvfield = None

මෙම කේත කොටස නිවැරදි දැයි ප්‍රශ්න නොමැත. එය කළ යුතු දේ එය කරන බව පැහැදිලිය.

මෙය සසඳා බලන්න

if csvfield == EMPTY_STRING:
    csvfield = None

මෙහි ඇති පළමු ප්‍රශ්නය නම්, හිස් නූලට විශේෂ ප්‍රතිකාර අවශ්‍ය වන්නේ ඇයි?

මෙය අනාගත කේතකරුවන්ට හිස් නූලක් සැමවිටම සැලකිය යුතු බව කියනු ඇත None.

එයට හේතුව එය ව්‍යාපාර තර්කනය (CSV අගය කුමක් විය යුතුද යන්නයි) None ) කේත ක්‍රියාත්මක කිරීම සමඟ මිශ්‍ර කිරීමයි (අප සැබවින්ම සැසඳෙන්නේ කුමක් ද)

දෙදෙනා අතර සැලකිල්ලෙන් වෙන්වීමක් තිබිය යුතුය .

a = ''
b = '   '
a.isspace() -> False
b.isspace() -> True

කොහොමද මේ? සමහර විට එය "වඩාත්ම අලංකාර" නොවේ, නමුත් එය සම්පුර්ණ හා පැහැදිලිව පෙනේ:

if (s is None) or (str(s).strip()==""): // STRING s IS "EMPTY"...

ඩොලර් 1290 ට ප්‍රතිචාර දක්වයි. කණගාටුයි, අදහස් දැක්වීමේදී කොටස් සැකසීමට ක්‍රමයක් නොමැත. මෙම Noneඅගය Python දී හිස් අගයක් නොවේ, සහ (හිස් තැන්) නොවේ. ඇන්ඩ rew ක්ලාක්ගේ පිළිතුර නිවැරදි ය : if not myString. @Ruuble වෙතින් ලැබෙන පිළිතුර යෙදුම් විශේෂිත වන අතර OP හි ප්‍රශ්නයට පිළිතුරු සපයන්නේ නැත. “හිස්” නූලක් යනු කුමක්ද යන්න පිළිබඳ සුවිශේෂී අර්ථ දැක්වීමක් අනුගමනය කළහොත් ඔබට කරදරයක් වනු ඇත. විශේෂයෙන්, සම්මත හැසිරීම යනු හිස් නොවන නූලක් str(None)නිපදවයි 'None'.

කෙසේ වෙතත්, ඔබ None(හිස්) “හිස්” නූල් ලෙස සැලකිය යුතු නම් , මෙන්න වඩා හොඳ ක්‍රමයක්:

class weirdstr(str):
    def __new__(cls, content):
        return str.__new__(cls, content if content is not None else '')
    def __nonzero__(self):
        return bool(self.strip())

උදාහරණ:

>>> normal = weirdstr('word')
>>> print normal, bool(normal)
word True

>>> spaces = weirdstr('   ')
>>> print spaces, bool(spaces)
    False

>>> blank = weirdstr('')
>>> print blank, bool(blank)
 False

>>> none = weirdstr(None)
>>> print none, bool(none)
 False

>>> if not spaces:
...     print 'This is a so-called blank string'
... 
This is a so-called blank string

boolනූල් වල අපේක්ෂිත හැසිරීම බිඳ නොදමන අතර rouble අවශ්‍යතා සපුරාලයි .

මම මෙය අලංකාර ලෙස සලකන්නේ එය නූලක් බව සහතික කර එහි දිග පරීක්ෂා කරමිනි:

def empty(mystring):
    assert isinstance(mystring, str)
    if len(mystring) == 0:
        return True
    else:
        return False

තවත් පහසු ක්‍රමයක් වන්නේ සරල ශ්‍රිතයක් අර්ථ දැක්වීම ය:

def isStringEmpty(inputString):
    if len(inputString) == 0:
        return True
    else:
        return False

not str(myString)

මෙම ප්‍රකාශනය හිස් නූල් සඳහා සත්‍ය වේ. හිස් නොවන නූල්, කිසිවක් සහ නූල් නොවන වස්තූන් සියල්ලම අසත්‍යය නිපදවනු ඇත, ව්‍යාජ වටිනාකමක් ලබා දීමෙන් මෙම තර්කනය වලක්වා ගැනීම සඳහා වස්තූන් __str__ අභිබවා යා හැකිය.

හිස් නූලක් හඳුනා ගැනීම සඳහා සරල ක්‍රමයක් පහත දැක්වේ:

a="" #Empty string
if(len(a)==0): #len() is used to find the length of the string or variable inside its' brackets.
   print("Empty")
else:
   print("Filled")

ඉහත ලෙන් () ක්‍රමය යනු යම් නිශ්චිත නූලක හෝ විචල්‍යයක දිග සොයා ගැනීමට උපකාරී වන ඉන්බිල්ට් ශ්‍රිතයකි . ලැයිස්තු සම්බන්ධයෙන්ද එය භාවිතා කළ හැකිය .

ලොජික්: අක්ෂරයේ හෝ විචල්‍යයේ දිග 0 නම් නියත වශයෙන්ම එයින් අදහස් වන්නේ නූල් හෝ විචල්‍යය හිස් බවය. නමුත් මෙය ක්‍රියාත්මක වන්නේ නූල් සහ ලැයිස්තු සම්බන්ධයෙන් මිස පූර්ණ සංඛ්‍යා සමඟ නොවන බව මතක තබා ගන්න. පහත දැක්වෙන්නේ පූර්ණ සංඛ්‍යා වල දිග සොයා ගැනීමේ කේතයයි.

a=int(input())
if(len(str(a))==0):
   print(True)

ඉහත කේතයේ str () භාවිතා කරනුයේ int එකක් 123 සිට එහි නූල් ආකෘතිය "123" දක්වා පරිවර්තනය කිරීමට ය. නූල් ආකෘතියෙන් එය වලංගු වේ.

ඔබට පයිතන් හි මෙම පැවරුම් හිස් අගය හෝ නූල දෙස බැලිය හැකිය

මෙය හිස් වූ නූල් සංසන්දනය කිරීමකි. එබැවින් හිස් බව සඳහා පරීක්‍ෂා කරනවා වෙනුවට, notඔබේ නූල හිස් නූලක් සමඟ හිස් නූලකට සමාන දැයි ඔබට පරීක්ෂා කළ හැකිය ""...

apache StringUtils.isBlank හෝ Guava Strings.isNullOrEmpty වැනි හැසිරීමක් අපේක්ෂා කරන අයට :

if mystring and mystring.strip():
    print "not blank string"
else:
    print "blank string"

ඔබ රේඛා අනුව ගොනුව කියවන විට සහ කුමන පේළිය හිස්ද යන්න තීරණය කිරීමට අවශ්‍ය විට, ඔබ භාවිතා කරන බවට වග බලා ගන්න .strip(), මන්ද “හිස්” පේළියේ නව රේඛා අක්‍ෂරයක් ඇත:

lines = open("my_file.log", "r").readlines()

for line in lines:
    if not line.strip():
        continue

    # your code for non-empty lines

str = ""
if not str:
   print "Empty String"
if(len(str)==0):
   print "Empty String"

ඔබ භාවිතා කරන්නේ නම්

not var1 

Falseහිස් නූලකින් බූලියන් වන විචල්‍යයක් වෙනස් කළ නොහැක '':

var1 = ''
not var1
> True

var1 = False
not var1
> True

කෙසේ වෙතත්, ඔබ ඔබේ ස්ක්‍රිප්ටයට සරල කොන්දේසියක් එකතු කරන්නේ නම්, වෙනස සිදු කරනු ලැබේ:

var1  = False
not var1 and var1 != ''
> True

var1 = ''
not var1 and var1 != ''
> False

මෙය යමෙකුට ප්‍රයෝජනවත් නම්, ලැයිස්තු වල ලැයිස්තු වල හිස් නූල් N / A සමඟ ආදේශ කිරීම සඳහා මම ගොඩනගා ඇති ඉක්මන් ශ්‍රිතයක් මෙන්න (පයිතන් 2).

y = [["1","2",""],["1","4",""]]

def replace_blank_strings_in_lists_of_lists(list_of_lists):
    new_list = []
    for one_list in list_of_lists:
        new_one_list = []
        for element in one_list:
            if element:
                new_one_list.append(element)
            else:
                new_one_list.append("N/A")
        new_list.append(new_one_list)
    return new_list


x= replace_blank_strings_in_lists_of_lists(y)
print x

ඇතැම් ක්ෂේත්‍ර සඳහා හිස් තැන් භාර නොගන්නා MySQL දත්ත ගබඩාවකට ලැයිස්තු ලැයිස්තු පළ කිරීම සඳහා මෙය ප්‍රයෝජනවත් වේ (ක්‍රමානුකූලව NN ලෙස සලකුණු කර ඇති ක්ෂේත්‍ර. මගේ නඩුවේ මෙය සංයුක්ත ප්‍රාථමික යතුරක් නිසා විය).

'', '', '\ N' වැනි නූල් සමඟ මම යම් අත්හදා බැලීමක් කළෙමි. මට අවශ්‍ය වන්නේ නොට් වයිට්ස්පේස් සත්‍යය නම් සහ විචල්‍ය foo අවම වශයෙන් එක් සුදු පැහැති නොවන අක්ෂරයක් සහිත නූලක් නම් පමණි. මම පයිතන් 3.6 භාවිතා කරමි. මෙන්න මම අවසන් කළ දේ:

isWhitespace = str is type(foo) and not foo.strip()
isNotWhitespace = str is type(foo) and not not foo.strip()

අවශ්‍ය නම් මෙය ක්‍රම අර්ථ දැක්වීමකින් ඔතා.

ප්‍රමත්ත ඉහත සඳහන් කළ පරිදි, නමුත් වැරදීමකින්.

def isNoneOrEmptyOrBlankString (myString):
    if myString:
        if not myString.strip():
            return True
        else:
            return False
    return False