උදාහරණයක් ලෙස, පහත සඳහන් දෑ සම්මත වුවහොත්:

a = []

aහිස් දැයි බැලීමට මා පරීක්ෂා කරන්නේ කෙසේද ?

if not a:
  print("List is empty")

හිස් වල ව්‍යාජ බූලියන් භාවිතා listකිරීම තරමක් පයිතොනික් ය.

එය සිදු කිරීම සඳහා පයිතොනික් ක්‍රමය වන්නේ PEP 8 විලාසිතාවේ මාර්ගෝපදේශයෙනි ( ඔව් යන්නෙහි තේරුම “නිර්දේශිත” සහ “නිර්දේශ නොකෙරේ ” යන්නෙහි තේරුම නැත):

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

Yes: if not seq:
     if seq:

No:  if len(seq):
     if not len(seq):

මම එයට පැහැදිලිවම කැමතියි:

if len(li) == 0:
    print('the list is empty')

මේ ආකාරයෙන් එය 100% ක් පැහැදිලි liවන අතර එය අනුක්‍රමයක් (ලැයිස්තුවක්) වන අතර අපට එහි ප්‍රමාණය පරීක්ෂා කිරීමට අවශ්‍යය. මට ඇති ගැටළුව if not li: ...නම් එය liබූලියන් විචල්‍යයක් වන ව්‍යාජ හැඟීම ලබා දීමයි.

_{මෙය "පයිතන් ටෙස්ට් හිස් අරාව" සහ ඒ හා සමාන විමසීම් සඳහා වන පළමු ගූගල් පහර වන අතර, අනෙක් අය ලැයිස්තුවෙන් ඔබ්බට ප්‍රශ්නය සාමාන්‍යකරණය කරන බවක් පෙනේ, එබැවින් මම සිතුවේ බොහෝ මිනිසුන්ගේ වෙනස් ආකාරයේ අනුක්‍රමයක් සඳහා අවවාදයක් එක් කිරීමටයි. භාවිතා කළ හැකිය.}

NumPy අරා සඳහා වෙනත් ක්‍රම ක්‍රියා නොකරයි

ඔබ NumPy අරා සමඟ ප්‍රවේශම් විය යුතුය, මන්ද lists හෝ වෙනත් සම්මත බහාලුම් සඳහා හොඳින් ක්‍රියා කරන වෙනත් ක්‍රම NumPy අරා සඳහා අසමත් වේ. පහත හේතුව මම පැහැදිලි කරමි, නමුත් කෙටියෙන් කිවහොත් වඩාත් කැමති ක්‍රමය භාවිතා කිරීමයි size.

"පයිතොනික්" ක්‍රමය ක්‍රියා නොකරයි: 1 වන කොටස

"පයිතොනික්" මාර්ගය NumPy අරා සමඟ අසමත් වන්නේ NumPy විසින් අරාව bools කාණ්ඩයකට දැමීමට if xඋත්සාහ කරන නිසාත්, ඒ සියල්ලම boolඑකවර කිසියම් සත්‍ය අගයක් සඳහා ඇගයීමට උත්සාහ කරන නිසාත් ය . නමුත් මෙය තේරුමක් නැති නිසා ඔබට මෙය ලැබෙනු ඇත ValueError:

>>> x = numpy.array([0,1])
>>> if x: print("x")
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

"පයිතොනික්" ක්‍රමය ක්‍රියා නොකරයි: 2 වන කොටස

නමුත් අවම වශයෙන් ඉහත නඩුව ඔබට පවසන්නේ එය අසාර්ථක වූ බවයි. ඔබට හරියටම එක් අංගයක් සහිත NumPy අරාවක් තිබේ නම්, එම ifප්‍රකාශය "ක්‍රියා කරයි", එයින් ඔබට දෝෂයක් නොලැබේ. කෙසේ වෙතත්, එම එක් අංගයක් 0(හෝ 0.0, හෝ False, ...) සිදුවුවහොත් , එම ifප්‍රකාශය වැරදි ලෙස ප්‍රති result ල වනු ඇත False:

>>> x = numpy.array([0,])
>>> if x: print("x")
... else: print("No x")
No x

නමුත් පැහැදිලිවම xපවතින අතර එය හිස් නොවේ! මෙම ප්‍රති result ලය ඔබට අවශ්‍ය දේ නොවේ.

භාවිතා lenකිරීමෙන් අනපේක්ෂිත ප්‍රති .ල ලබා ගත හැකිය

උදාහරණයක් වශයෙන්,

len( numpy.zeros((1,0)) )

අරාවෙහි ශුන්‍ය මූලද්‍රව්‍ය තිබුණද 1 නැවත ලබා දෙයි.

අංකිත ක්‍රමය

SciPy නිති අසන ප්‍රශ්නවල පැහැදිලි කර ඇති පරිදි , ඔබට NumPy අරාවක් ඇති බව ඔබ දන්නා සෑම අවස්ථාවකම නිවැරදි ක්‍රමය භාවිතා කිරීම if x.size:

>>> x = numpy.array([0,1])
>>> if x.size: print("x")
x

>>> x = numpy.array([0,])
>>> if x.size: print("x")
... else: print("No x")
x

>>> x = numpy.zeros((1,0))
>>> if x.size: print("x")
... else: print("No x")
No x

එය A list, NumPy අරාව හෝ වෙනත් දෙයක් විය හැකිදැයි ඔබට විශ්වාස නැත්නම්, ඔබට මෙම ප්‍රවේශය එක් එක් වර්ගය සඳහා නිවැරදි පරීක්ෂණය භාවිතා කරන බවට වග බලා ගැනීම සඳහා @dubiousjim ලබා දෙන පිළිතුර සමඟ ඒකාබද්ධ කළ හැකිය . එතරම් "පයිතොනික්" නොවේ, නමුත් NumPy හිතාමතාම අවම වශයෙන් මෙම අර්ථයෙන් පයිතොනික් භාවය බිඳ දැමූ බව පෙනේ.

ආදාන හිස් නම් ඔබ චෙක් වඩා වැඩි දෙයක් කිරීමට අවශ්ය, ඔබ වෙනත් NumPy භාවිතා කරන්නේ නම්, සූචිගත හෝ ගණිත මෙහෙයුම් වැනි ලක්ෂණ, එය ආදාන බල වඩාත් කාර්යක්ෂම (සහ නිසැකව වඩාත් පොදු), බොහෝ දුරට විය එය NumPy සාධක විය. මෙය ඉක්මණින් සිදු කිරීම සඳහා හොඳ කාර්යයන් කිහිපයක් තිබේ - වඩාත්ම වැදගත් දෙය numpy.asarray. මෙය ඔබගේ ආදානය ගනී, එය දැනටමත් අරාවක් නම් කිසිවක් නොකරයි, නැතහොත් එය ලැයිස්තුවක්, ටුපල් යනාදිය නම් ඔබේ ආදානය අරාවකට ඔතා, විකල්පයක් ලෙස ඔබ තෝරාගත් දේ බවට පරිවර්තනය කරයි dtype. එබැවින් එය විය හැකි සෑම විටම එය ඉතා ඉක්මන් වන අතර, එමඟින් ආදානය NumPy අරාව යැයි උපකල්පනය කිරීම සහතික කරයි. අරාවකට පරිවර්තනය කිරීමෙන් එය වර්තමාන විෂය පථයෙන් පරිබාහිර නොවන බැවින් අපි සාමාන්‍යයෙන් එකම නම පමණක් භාවිතා කරමු :

x = numpy.asarray(x, dtype=numpy.double)

අතර පත් කරනු x.sizeමම මේ පිටුවේ දකින සියලු අවස්ථාවල දී පරීක්ෂා වැඩ.

ලැයිස්තුවක් හිස් දැයි පරීක්ෂා කිරීමට හොඳම ක්‍රමය

උදාහරණයක් ලෙස, පහත සඳහන් දෑ සම්මත වුවහොත්:

a = []

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

කෙටි පිළිතුර:

ලැයිස්තුව බූලියන් සන්දර්භයක තබන්න (නිදසුනක් ලෙස, ප්‍රකාශයක් ifහෝ whileප්‍රකාශයක් සමඟ). එය Falseහිස් දැයි පරීක්ෂා කරනු ඇත True. උදාහරණයක් වශයෙන්:

if not a:                           # do this!
    print('a is an empty list')

PEP 8

පයිතන්ගේ සම්මත පුස්තකාලයේ පයිතන් කේතය සඳහා නිල පයිතන් විලාසිතාවේ මාර්ගෝපදේශය වන පීඊපී 8 අවධාරනය කරයි:

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

Yes: if not seq:
     if seq:

No: if len(seq):
    if not len(seq):

සම්මත පුස්තකාල කේතය හැකි තරම් ක්‍රියාකාරී හා නිවැරදි විය යුතු යැයි අපි අපේක්ෂා කළ යුතුය. නමුත් එය එසේ වන්නේ ඇයි? අපට මෙම මග පෙන්වීම අවශ්‍ය වන්නේ ඇයි?

පැහැදිලි කිරීම

පළපුරුදු ක්‍රමලේඛකයින්ගේ සිට පයිතන් දක්වා නව කේත මම නිතර දකිමි:

if len(a) == 0:                     # Don't do this!
    print('a is an empty list')

කම්මැලි භාෂා භාවිතා කරන්නන් මෙය කිරීමට පෙළඹවිය හැකිය:

if a == []:                         # Don't do this!
    print('a is an empty list')

මේවා ඔවුන්ගේ වෙනත් භාෂාවලින් නිවැරදි ය. පයිතන්හි මෙය අර්ථාන්විතව පවා නිවැරදි ය.

නමුත් අපි එය පයිතොනික් නොවන බව සලකන්නේ බූලියන් බලහත්කාරය හරහා ලැයිස්තු වස්තුවෙහි අතුරුමුහුණතට පයිතන් මෙම අර්ථකථන සඳහා සෘජුවම සහාය දක්වන බැවිනි.

සිට ලේඛන (හිස් ලැයිස්තුව විශේෂයෙන් ඇතුළත් කිරීම සහ සටහන්, []):

පෙරනිමියෙන්, වස්තුවක් සත්‍ය ලෙස සලකනු ලබන්නේ එහි පන්තිය විසින් __bool__()නැවත පැමිණෙන ක්‍රමයක් Falseහෝ __len__()ශුන්‍යය ලබා දෙන ක්‍රමයක් නිර්වචනය නොකළහොත් පමණි . ව්‍යාජ ලෙස සලකනු ලබන සාදන ලද වස්තූන් බොහොමයක් මෙන්න:

• නියතයන් ව්‍යාජ යැයි අර්ථ දක්වා ඇත: Noneසහ False.
• ඕනෑම සංඛ්යා වර්ගයේ ශුන්ය: 0, 0.0, 0j, Decimal(0),Fraction(0, 1)
• ෙවල සහ එකතු හිස්: '', (), [], {}, set(),range(0)

සහ ඩේටමොඩෙල් ප්‍රලේඛනය:

object.__bool__(self)

සත්‍ය අගය පරීක්ෂා කිරීම සහ ගොඩනංවන ලද ක්‍රියාකාරිත්වය ක්‍රියාත්මක කිරීමට කැඳවනු ලැබේ bool(); ආපසු යා යුතුය Falseහෝ True. මෙම ක්‍රමය නිර්වචනය කර නොමැති විට __len__(), එය නිර්වචනය කර ඇත්නම් එය හැඳින්වේ, සහ එහි ප්‍රති result ලය අස්ථිර නම් වස්තුව සත්‍ය ලෙස සැලකේ. පංතියක් අර්ථ දක්වන්නේ __len__() නැතත් __bool__(), එහි සියලු අවස්ථා සත්‍ය ලෙස සැලකේ.

හා

object.__len__(self)

සාදන ලද කාර්යය ක්‍රියාත්මක කිරීමට කැඳවනු ලැබේ len(). වස්තුවක දිග, පූර්ණ සංඛ්‍යාවක්> = 0. ආපසු ලබා දිය යුතුය. එසේම, __bool__()ක්‍රමයක් නිර්වචනය නොකරන වස්තුවක් __len__()ශුන්‍යය ලබා දෙන වස්තුවක් බූලියන් සන්දර්භය තුළ අසත්‍යයක් ලෙස සැලකේ.

එබැවින් මේ වෙනුවට:

if len(a) == 0:                     # Don't do this!
    print('a is an empty list')

හෝ මෙය:

if a == []:                     # Don't do this!
    print('a is an empty list')

මෙය කරන්න:

if not a:
    print('a is an empty list')

පයිතොනික් දේ කිරීම සාමාන්‍යයෙන් කාර්ය සාධනයෙන් ගෙවනු ලැබේ:

එය ගෙවනවාද? (සමාන මෙහෙයුමක් කිරීමට අඩු කාලයක් වඩා හොඳ බව සලකන්න :)

>>> import timeit
>>> min(timeit.repeat(lambda: len([]) == 0, repeat=100))
0.13775854044661884
>>> min(timeit.repeat(lambda: [] == [], repeat=100))
0.0984637276455409
>>> min(timeit.repeat(lambda: not [], repeat=100))
0.07878462291455435

පරිමාණය සඳහා, ශ්‍රිතය ඇමතීමේ සහ හිස් ලැයිස්තුවක් තැනීමේ සහ ආපසු යැවීමේ පිරිවැය මෙන්න, ඉහත භාවිතා කළ හිස්බව චෙක්පත් වල පිරිවැයෙන් ඔබට අඩු කළ හැකිය:

>>> min(timeit.repeat(lambda: [], repeat=100))
0.07074015751817342

අපි බලන්න එක්කෝ මෙම builtin ක්රියාකාරිත්වයට දිග සඳහා පරීක්ෂා කිරීම lenහා සසඳන 0 හෝ හිස් ලැයිස්තුව එරෙහිව පිරික්සුමක් බොහෝ ලේඛනගත ලෙස භාෂාව builtin කාරක රීති භාවිතා වඩා අඩු performant.

මන්ද?

සඳහා len(a) == 0 චෙක්:

පළමුවෙන්ම පයිතන්ට ග්ලෝබල් පරික්ෂා කර බැලීමට සිදුවේ len .

එවිට එය 0පයිතන්හි (C සමඟ වෙනුවට) ශ්‍රිතය, පැටවීම සහ සමානාත්මතාවය සැසඳිය යුතුය:

>>> import dis
>>> dis.dis(lambda: len([]) == 0)
  1           0 LOAD_GLOBAL              0 (len)
              2 BUILD_LIST               0
              4 CALL_FUNCTION            1
              6 LOAD_CONST               1 (0)
              8 COMPARE_OP               2 (==)
             10 RETURN_VALUE

ඒ සඳහා [] == []එයට අනවශ්‍ය ලැයිස්තුවක් සෑදිය යුතු අතර, නැවතත්, පයිතන්ගේ අතථ්‍ය යන්ත්‍රයේ සංසන්දනාත්මක මෙහෙයුම කරන්න (C ට වඩා වෙනස්ව)

>>> dis.dis(lambda: [] == [])
  1           0 BUILD_LIST               0
              2 BUILD_LIST               0
              4 COMPARE_OP               2 (==)
              6 RETURN_VALUE

වස්තු නිදර්ශන ශීර්ෂය තුළ ලැයිස්තුවේ දිග හැඹිලිගත කර ඇති බැවින් "පයිතොනික්" මාර්ගය වඩාත් සරල හා වේගවත් පරීක්ෂාවකි:

>>> dis.dis(lambda: not [])
  1           0 BUILD_LIST               0
              2 UNARY_NOT
              4 RETURN_VALUE

සී ප්‍රභවයෙන් සහ ප්‍රලේඛනයෙන් සාක්ෂි

PyVarObject

මෙය ක්ෂේත්‍රය PyObjectඑකතු කරන දිගුවකි ob_size. මෙය භාවිතා කරනුයේ දිග පිළිබඳ යම් අදහසක් ඇති වස්තූන් සඳහා පමණි. මෙම වර්ගය බොහෝ විට පයිතන් / සී API හි නොපෙන්වයි. එය PyObject_VAR_HEADසාර්ව ප්‍රසාරණය මගින් අර්ථ දක්වා ඇති ක්ෂේත්‍රයන්ට අනුරූප වේ .

ඇතුළත් කරන්න / listobject.h හි c ප්‍රභවයෙන් :

typedef struct {
    PyObject_VAR_HEAD
    /* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */
    PyObject **ob_item;

    /* ob_item contains space for 'allocated' elements.  The number
     * currently in use is ob_size.
     * Invariants:
     *     0 <= ob_size <= allocated
     *     len(list) == ob_size

අදහස් වලට ප්‍රතිචාර:

l=[]එවකට %timeit len(l) != 090.6 ns ± 8.3 ns, %timeit l != []55.6 ns ± 3.09, %timeit not not l38.5 ns ± 0.372 හා සසඳන විට හිස් නොවන නඩුව සඳහා ද මෙය සත්‍ය බව මම පෙන්වා දෙමි . නමුත් not not lතුන් ගුණයක වේගයක් තිබියදීත් කිසිවෙකු භුක්ති විඳීමට ක්‍රමයක් නොමැත . එය හාස්‍යජනක ලෙස පෙනේ. නමුත් වේගය ජය ගනී
යැයි සිතමි, ගැටලුව කාලානුරූපව පරික්ෂා කිරීම if l:ප්‍රමාණවත් බැවින් එය ප්‍රමාණවත් නමුත් පුදුම සහගත ලෙස %timeit bool(l)අස්වැන්න 101 ns ± 2.64 ns. සිත්ගන්නා කරුණ නම් මෙම ද .ුවම නොමැතිව බූල් කිරීමට බල කිරීමක් නැත. %timeit lපරිවර්තනයක් සිදු නොවන බැවින් නිෂ් less ල ය.

IPython magic, %timeitමෙහි සම්පූර්ණයෙන්ම නිෂ් less ල නොවේ:

In [1]: l = []                                                                  

In [2]: %timeit l                                                               
20 ns ± 0.155 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

In [3]: %timeit not l                                                           
24.4 ns ± 1.58 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [4]: %timeit not not l                                                       
30.1 ns ± 2.16 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

notමෙහි එක් එක් අමතර සඳහා රේඛීය පිරිවැයක් ඇති බව අපට පෙනේ . අපට අවශ්‍ය වන්නේ පිරිවැය, සෙටෙරිස් පරිබුස් , එනම් අනෙක් සියල්ලම එක හා සමානයි - අනෙක් සියල්ල හැකි තරම් අවම කර ඇති තැන:

In [5]: %timeit if l: pass                                                      
22.6 ns ± 0.963 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [6]: %timeit if not l: pass                                                  
24.4 ns ± 0.796 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [7]: %timeit if not not l: pass                                              
23.4 ns ± 0.793 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

දැන් අපි නොවරදින ලැයිස්තුවක් සඳහා නඩුව දෙස බලමු:

In [8]: l = [1]                                                                 

In [9]: %timeit if l: pass                                                      
23.7 ns ± 1.06 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [10]: %timeit if not l: pass                                                 
23.6 ns ± 1.64 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [11]: %timeit if not not l: pass                                             
26.3 ns ± 1 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

අපට මෙහි දැකිය හැකි දෙය නම්, ඔබ සත්‍ය වශයෙන්ම සමත් වුවද එයින් සුළු වෙනසක් සිදු වන බවයි bool කොන්දේසි පරීක්‍ෂණයට හෝ ලැයිස්තුවට වන අතර, යමක් තිබේ නම්, ලැයිස්තුව ලබා දීම වේගවත් වේ.

පයිතන් සී හි ලියා ඇත; එය සී මට්ටමින් එහි තර්කනය භාවිතා කරයි. ඔබ පයිතන් හි ලියන ඕනෑම දෙයක් මන්දගාමී වනු ඇත. ඔබ කෙලින්ම පයිතන් තුළ ගොඩනගා ඇති යාන්ත්‍රණයන් භාවිතා නොකරන්නේ නම් එය විශාලත්වයේ අනුපිළිවෙලක් වනු ඇත.

සත්‍ය වටිනාකම් පරික්ෂා කිරීමේදී හිස් ලැයිස්තුවක් සාවද්‍ය යැයි සැලකේ ( පයිතන් ප්‍රලේඛනය බලන්න ):

a = []
if a:
     print "not empty"

@ ඩැරන් තෝමස්

සංස්කරණය කරන්න: හිස් ලැයිස්තුව වැරදි ලෙස පරීක්ෂා කිරීමට එරෙහි තවත් කරුණක්: බහුමාපකය ගැන කුමක් කිව හැකිද? ඔබ ලැයිස්තුවක් ලැයිස්තුවක් මත රඳා නොසිටිය යුතුය. එය තාරාවෙකු මෙන් විය යුතුය - මූලද්‍රව්‍යයන් නොමැති විට ඔබේ තාරාවන්ගේ එකතුව '' අසත්‍යය '' ඉවත් කිරීමට යන්නේ කෙසේද?

ඔබගේ duckCollection ක්රියාත්මක කළ යුතු __nonzero__හෝ __len__එසේ නම්, එවැනි: ප්රශ්නයක් නොමැතිව වැඩ කරනු ඇත.

පැට්රික්ගේ (පිළිගත්) පිළිතුර හරි: if not a:එය කිරීමට නිවැරදි ක්‍රමයයි. හාර්ලි හොල්කොම්බ්ගේ පිළිතුර මෙය PEP 8 විලාසිතාවේ මාර්ගෝපදේශයේ ඇති බව නිවැරදිය. නමුත් කිසිම පිළිතුරක් පැහැදිලි නොකරන දෙය නම් මෝඩකම අනුගමනය කිරීම හොඳ අදහසක් - ඔබ පෞද්ගලිකව එය ප්‍රමාණවත් ලෙස හෝ රූබි පරිශීලකයින්ට හෝ වෙනත් දෙයකට ව්‍යාකූල නොවන බව සොයා ගත්තද.

පයිතන් කේතය සහ පයිතන් ප්‍රජාවට ඉතා ශක්තිමත් මෝඩයන් ඇත. එම මෝඩයන් අනුගමනය කිරීමෙන් ඔබේ කේතය පයිතන් හි අත්දැකීම් ඇති ඕනෑම කෙනෙකුට කියවීමට පහසු වේ. ඔබ එම මෝඩයන් උල්ලං When නය කරන විට එය ප්‍රබල සං .ාවකි.

එය සත්ය බව if not a:සිට හිස් ලැයිස්තු වෙනස හඳුනා නැත None, හෝ සංඛ්යා 0, හෝ හිස් tuples, හෝ හිස් පරිශීලක-නිර්මාණය එකතුව වර්ග, හෝ හිස් පරිශීලක-නිර්මාණය නොවන-තරමක්-එකතු වර්ග, හෝ තනි-අංගයක් NumPy මාලාවක් falsey සමග scalars ලෙස කටයුතු සාරධර්ම ආදිය. සමහර විට ඒ ගැන පැහැදිළි වීම වැදගත් ය. එවැනි අවස්ථාවක, ඔබට පැහැදිලි වීමට අවශ්‍ය දේ ඔබ දන්නවා , ඒ නිසා ඔබට ඒ සඳහා හරියටම පරීක්ෂා කළ හැකිය. නිදසුනක් ලෙස, if not a and a is not None:"කිසිවක් හැර අන් කිසිවක් වැරදියි" if len(a) != 0:යන්නෙහි තේරුම "හිස් අනුක්‍රමයන් පමණි" සහ අනුක්‍රමයක් හැර වෙනත් කිසිවක් මෙහි දෝෂයකි "සහ යනාදිය. ඔබට පරීක්ෂා කිරීමට අවශ්‍ය දේ හරියටම පරීක්ෂා කිරීමට අමතරව, මෙම පරීක්ෂණය වැදගත් බව පා er කයාට සං als ා කරයි.

නමුත් ඔබට පැහැදිලිව ප්‍රකාශ කිරීමට කිසිවක් නොමැති විට, හැර වෙනත් කිසිවක් පා if not a:er කයා නොමඟ යවයි. එය වැදගත් නොවන විට ඔබ සං sign ා කරයි. (ඔබ ද අඩු නම්යශීලී, හෝ මන්දගාමී, හෝ ඕනෑම දෙයක්, නමුත් එම සියළු අඩු වැදගත් වන්නේ, එම කේතය හැකි ය.) ඔබ නම් පුරුද්දක් ලෙස ඔබ පැමිණි විට, මේ වගේ පාඨකයා නොමග යැවීමට කළ වෙනසක් කිරීමට අවශ්ය, එය අවධානයට ලක් නිසා සම්මත කිරීමට යන්නේ ඔබ ඔබේ කේතය පුරාම "අ crying න වෘකයා" වී ඇත.

කිසිසේත් පරීක්ෂා කරන්නේ ඇයි?

ලැයිස්තුව මුලින්ම පරීක්ෂා කිරීමේ ඔබේ අවශ්‍යතාවය ප්‍රශ්න කිරීමට කිසිවෙකු ආමන්ත්‍රණය කර ඇති බවක් නොපෙනේ . ඔබ අමතර සන්දර්භයක් ලබා දී නැති නිසා, ඔබට මෙම පරීක්‍ෂණය මුලින් කිරීමට අවශ්‍ය නොවනු ඇතැයි මට සිතිය හැකිය, නමුත් පයිතන් හි ලැයිස්තු සැකසීම පිළිබඳව නුහුරු ය.

මම තර්ක කරන්නේ වඩාත්ම පයිතොනික් ක්‍රමය වන්නේ කිසිසේත් පරීක්ෂා නොකිරීම නොව ලැයිස්තුව සැකසීම බවයි. ඒ ආකාරයෙන් එය හිස් හෝ පිරී තිබුණත් නිවැරදි දේ කරනු ඇත.

a = []

for item in a:
    <do something with item>

<rest of code>

මේ කිසිවක් අඩංගු කටයුතු යහපත ඇති වන හිස්බව සඳහා නිශ්චිත චෙක්පත අවශ්ය නොවන අතර,. නම් වූ හිස්, යෑපෙන වාරණ ක්රියාත්මක නොවන අතර භාෂණ ඊළඟ රේඛාව හරහා වැටෙනු ඇත.

ඔබට ඇත්ත වශයෙන්ම හිස්බව සඳහා අරාව පරීක්ෂා කිරීමට අවශ්‍ය නම්, අනෙක් පිළිතුරු ප්‍රමාණවත් වේ.

len()යනු පයිතන් ලැයිස්තු, නූල්, ඩික්ට්ස් සහ කට්ටල සඳහා O (1) මෙහෙයුමකි . පයිතන් අභ්‍යන්තරව මෙම බහාලුම්වල ඇති මූලද්‍රව්‍ය ගණන නිරීක්ෂණය කරයි.

ජාවාස්ක්‍රිප්ට්හි සත්‍ය / ව්‍යාජ පිළිබඳ සමාන අදහසක් ඇත .

මම ලියා තිබුණා:

if isinstance(a, (list, some, other, types, i, accept)) and not a:
    do_stuff

ඡන්දය දුන් -1. පා readers කයන් උපාය මාර්ගයට විරුද්ධ වූ නිසා හෝ ඉදිරිපත් කළ පරිදි පිළිතුර ප්‍රයෝජනවත් නොවේ යැයි සිතූ නිසාදැයි මට විශ්වාස නැත. --- “පයිතොනික්” ලෙස සලකන ඕනෑම දෙයක් --- මෙය නිවැරදි උපාය මාර්ගය බැවින් මම එය දෙවැන්න යැයි මවා පෙන්වන්නෙමි. ඔබ දැනටමත් බැහැර කර නොමැති නම් හෝ සිද්ධීන් හැසිරවීමට සුදානම් නොවන්නේ aනම්, උදාහරණයක් ලෙස False, ඔබට අවශ්‍ය වන්නේ වඩා සීමිත පරීක්ෂණයක් පමණි if not a:. ඔබට මේ වගේ දෙයක් භාවිතා කළ හැකිය:

if isinstance(a, numpy.ndarray) and not a.size:
    do_stuff
elif isinstance(a, collections.Sized) and not a:
    do_stuff

පළමු පරීක්ෂණය @ මයික්ගේ පිළිතුරට ඉහළින්. තෙවන පේළිය ද ආදේශ කළ හැකිය:

elif isinstance(a, (list, tuple)) and not a:

ඔබට අවශ්‍ය වන්නේ විශේෂිත වර්ගවල (සහ ඒවායේ උප වර්ගවල) අවස්ථා පමණක් පිළිගැනීමට නම්, හෝ සමඟ:

elif isinstance(a, (list, tuple)) and not len(a):

පැහැදිලි ආකාරයේ පරීක්ෂාවකින් තොරව ඔබට පලා යා හැකිය, නමුත් aඔබ හැසිරවීමට සූදානම් කර ඇති වර්ගවල වටිනාකම එය බව අවට සන්දර්භය දැනටමත් ඔබට සහතික කර තිබේ නම් හෝ ඔබ හැසිරවීමට සූදානම් නැති වර්ග යන බව ඔබට විශ්වාස නම් ඔබ හැසිරවීමට සූදානම්ව ඇති දෝෂ මතු කිරීමට (උදා: TypeErrorඔබ lenඑය නිර්වචනය නොකළ අගයක් ඉල්ලා සිටියහොත් ). පොදුවේ ගත් කල, "පයිතොනික්" සම්මුතීන් මෙම අන්තිම මාර්ගයට යන බව පෙනේ. එය තාරාවෙකු මෙන් මිරිකා එය තාරා දෝෂයක් මතු කිරීමට ඉඩ දෙන්න. ඔබ තවමත් කුමන ආකාරයේ උපකල්පන සිදු කරන්නේද යන්න ගැන සිතා බැලිය යුතු අතර, නිසි ලෙස හැසිරවීමට ඔබ සූදානම් නැති අවස්ථා ඇත්ත වශයෙන්ම නිවැරදි ස්ථානවල වැරදි සිදුවන්නේද යන්න ගැන. නැම්පි අරා යනු අන්ධ ලෙස රඳා පවතින හොඳ උදාහරණයකිlen හෝ බූලියන් යතුරුලියනය ඔබ අපේක්ෂා කරන දේ හරියටම නොකරයි.

සිට ප්රලේඛනය සත්යය අගය පරීක්ෂා කිරීම පිළිබඳ:

මෙහි ලැයිස්තුගත කර ඇති දේ හැර අනෙකුත් සියලුම අගයන් සලකා බලනු ලැබේ True

• None
• False
• ඕනෑම සංඛ්යා වර්ගයේ ශුන්ය, උදාහරණයක් ලෙස, 0, 0.0, 0j.
• ඕනෑම හිස් අනුක්රමය, උදාහරණයක් ලෙස, '', (), [].
• ඕනෑම හිස් සිතියම්කරණයක්, උදාහරණයක් ලෙස {}.
• පරිශීලක-නිර්වචනය කරන ලද පංතිවල අවස්ථා, පන්තිය a __bool__()හෝ __len__()ක්‍රමයක් නිර්වචනය කරන්නේ නම් , එම ක්‍රමය පූර්ණ සංඛ්‍යා ශුන්‍ය හෝ බූල් අගය ලබා දෙන විට False.

ලෙස දැකිය හැක, හිස් ලැයිස්තුවක් []වේ falsy , ඒ නිසා ශබ්ද වඩාත් කාර්යක්ෂම වූ වීජ අගය කිරීමට සිදු වන්නේ කුමක්ද කරන්නේ:

if not a:
    print('"a" is empty!')

ලැයිස්තුවක් හිස් දැයි ඔබට පරීක්ෂා කළ හැකි ක්‍රම කිහිපයක් මෙන්න:

a = [] #the list

1) ලස්සන සරල පයිතොනික් ක්‍රමය:

if not a:
    print("a is empty")

පයිතන් හි හිස් බහාලුම් වන ලැයිස්තු, ටුපල්, කට්ටල, ඩික්ට්ස්, විචල්යයන් යනාදිය දක්නට ලැබේ False. කෙනෙකුට හුදෙක් ලැයිස්තුව පුරෝකථනය කළ හැකිය ( බූලියන් අගයක් ලබා දීම ). සහ Trueඅගය එය, හිස්-නොවන බව, පෙන්වා ඇත.

2) වඩාත් පැහැදිලි ක්‍රමයක්: len()දිග සොයා ගැනීමට භාවිතා කිරීම හා එය සමාන දැයි පරීක්ෂා කරන්න 0:

if len(a) == 0:
    print("a is empty")

3) හෝ එය නිර්නාමික හිස් ලැයිස්තුවකට සංසන්දනය කිරීම:

if a == []:
    print("a is empty")

4) කළ යුතු තවත් මෝඩ ක්‍රමයක් වන්නේ exceptionසහ iter():

try:
    next(iter(a))
    # list has elements
except StopIteration:
    print("Error: a is empty")

මම පහත සඳහන් දේට කැමතියි:

if a == []:
   print "The list is empty."

ක්රමය 1 (කැමති):

if not a : 
   print ("Empty") 

ක්රමය 2:

if len(a) == 0 :
   print( "Empty" )

ක්රමය 3:

if a == [] :
  print ("Empty")

def list_test (L):
    if   L is None  : print('list is None')
    elif not L      : print('list is empty')
    else: print('list has %d elements' % len(L))

list_test(None)
list_test([])
list_test([1,2,3])

සමහර විට Noneඒවා එකිනෙකට වෙනස් රාජ්‍යයන් දෙකක් බැවින් හිස් බව සඳහා වෙන වෙනම පරීක්ෂා කිරීම හොඳය . ඉහත කේතය පහත ප්‍රතිදානය නිපදවයි:

list is None 
list is empty 
list has 3 elements

එය කිසි වැදගැම්මකට නැති Noneදෙයක් වුවද. එබැවින් None-ness සඳහා පරීක්ෂණය වෙන් කිරීමට ඔබට අවශ්‍ය නැතිනම්, ඔබ එය කළ යුතු නැත.

def list_test2 (L):
    if not L      : print('list is empty')
    else: print('list has %d elements' % len(L))

list_test2(None)
list_test2([])
list_test2([1,2,3])

අපේක්ෂිත නිෂ්පාදනය කරයි

list is empty
list is empty
list has 3 elements

බොහෝ පිළිතුරු ලබා දී ඇති අතර, ඒවායින් බොහොමයක් හොඳයි. මට අවශ්‍ය වූයේ එම චෙක්පත එක් කිරීමට ය

not a

Noneවෙනත් හිස් ව්‍යුහයන් සඳහා ද සම්මත වනු ඇත . ඔබට සැබවින්ම හිස් ලැයිස්තුවක් පරීක්ෂා කිරීමට අවශ්‍ය නම්, ඔබට මෙය කළ හැකිය:

if isinstance(a, list) and len(a)==0:
    print("Received an empty list")

අපට වෙනත් ආකාරයකින් සරල භාවිතා කළ හැකිය:

item_list=[]
if len(item_list) == 0:
    print("list is empty")
else:
    print("list is not empty")

Ub ඩුබියස්ජිම්ගේ විසඳුමෙන් දේවානුභාවයෙන්, එය නැවත කළ හැකි දෙයක්ද යන්න පිළිබඳ අතිරේක පොදු පරීක්‍ෂණයක් භාවිතා කිරීමට මම යෝජනා කරමි

import collections
def is_empty(a):
    return not a and isinstance(a, collections.Iterable)

සටහන: නූලක් නැවත කළ හැකි යැයි සැලකේ. - and not isinstance(a,(str,unicode))හිස් නූල බැහැර කිරීමට ඔබට අවශ්‍ය නම් එකතු කරන්න

පරීක්ෂණය:

>>> is_empty('sss')
False
>>> is_empty(555)
False
>>> is_empty(0)
False
>>> is_empty('')
True
>>> is_empty([3])
False
>>> is_empty([])
True
>>> is_empty({})
True
>>> is_empty(())
True

print('not empty' if a else 'empty')

තව ටිකක් ප්‍රායෝගික:

a.pop() if a else None

සහ ෂර්ටෙස්ට් අනුවාදය:

if a: a.pop() 

ලැයිස්තුවක් හිස් දැයි පරීක්ෂා කිරීමට ඔබට අවශ්‍ය නම්:

l = []
if l:
    # do your stuff.

ලැයිස්තුවේ ඇති සියලුම අගයන් හිස් දැයි පරීක්ෂා කිරීමට ඔබට අවශ්‍ය නම්. කෙසේ වෙතත් එය Trueහිස් ලැයිස්තුවක් සඳහා වනු ඇත :

l = ["", False, 0, '', [], {}, ()]
if all(bool(x) for x in l):
    # do your stuff.

ඔබට අවස්ථා දෙකම එකට භාවිතා කිරීමට අවශ්‍ය නම්:

def empty_list(lst):
    if len(lst) == 0:
        return False
    else:
        return all(bool(x) for x in l)

දැන් ඔබට භාවිතා කළ හැකිය:

if empty_list(lst):
    # do your stuff.

Python3 සිට ඔබට භාවිතා කළ හැකිය

a == []

ලැයිස්තුව හිස් දැයි පරීක්ෂා කිරීමට

සංස්කරණය කරන්න: මෙය python2.7 සමඟද ක්‍රියා කරයි ..

මෙතරම් සංකීර්ණ පිළිතුරු ඇත්තේ මන්දැයි මට විශ්වාස නැත. එය ඉතා පැහැදිලිය

ඔබට මේ වගේ bool () භාවිතා කිරීමට පවා උත්සාහ කළ හැකිය

    a = [1,2,3];
    print bool(a); # it will return True
    a = [];
    print bool(a); # it will return False

පිරික්සුම් ලැයිස්තුව හිස්ද නැද්ද යන්න මම මේ ආකාරයට කැමතියි.

ඉතා පහසු සහ ප්‍රයෝජනවත්.

Is_empty () භාවිතා කරන්න හෝ ක්‍රියා කරන්න: -

def is_empty(any_structure):
    if any_structure:
        print('Structure is not empty.')
        return True
    else:
        print('Structure is empty.')
        return False  

ලැයිස්තුවක්, ටුපල්, ශබ්දකෝෂය සහ තවත් බොහෝ දත්ත_ ව්‍යුහයක් සඳහා එය භාවිතා කළ හැකිය. මේවායින්, ඔබට එය සාධාරණ ලෙස භාවිතා කර බොහෝ වාරයක් ඇමතිය හැකිය is_empty(any_structure).

සරල ක්‍රමය නම් දිග සමාන ශුන්‍යයක් දැයි පරීක්ෂා කිරීමයි.

if len(a) == 0:
    print("a is empty")

හිස් ලැයිස්තුවක සත්‍ය වටිනාකම වන අතර හිස් Falseනොවන ලැයිස්තුවක් සඳහා එය වේ True.

මා මෙහි ගෙන ආවේ විශේෂ භාවිත අවස්ථාවක්: මට ඇත්ත වශයෙන්ම අවශ්‍ය වූයේ ලැයිස්තුවක් හිස්ද නැද්ද යන්න මට පැවසීමට ශ්‍රිතයක් . මට අවශ්‍ය වූයේ මගේම ශ්‍රිතයක් ලිවීමෙන් හෝ මෙහි ලැම්බඩා ප්‍රකාශනයක් භාවිතා කිරීමෙන් වැළකී සිටීමටයි (මන්ද එය ප්‍රමාණවත් තරම් සරල විය යුතු බව පෙනෙන නිසා):

foo = itertools.takewhile(is_not_empty, (f(x) for x in itertools.count(1)))

ඇත්ත වශයෙන්ම, එය කිරීමට ඉතා ස්වාභාවික ක්‍රමයක් තිබේ:

foo = itertools.takewhile(bool, (f(x) for x in itertools.count(1)))

ඇත්ත වශයෙන්ම, නෑ නෑ භාවිතා boolදී if(එනම්, if bool(L):එයින් කියවෙන්නේ කරන නිසා). එහෙත්, "හිස් නොවන" අවස්ථාවන් සඳහා පැහැදිලිවම ශ්‍රිතයක් ලෙස අවශ්‍ය වන විට, boolහොඳම තේරීම වේ.

ලැයිස්තුවක් හිස්ද නැද්ද යන්න පරීක්ෂා කිරීමට ඔබට පහත ක්‍රම දෙකක් භාවිතා කළ හැකිය. නමුත් මතක තබා ගන්න, අපි යම් අනුක්‍රමයක් සඳහා පැහැදිලිව පරික්ෂා කිරීමේ ක්‍රමයෙන් වැළකී සිටිය යුතුය (එය less pythonicක්‍රමයක්):

def enquiry(list1): 
    if len(list1) == 0: 
        return 0
    else: 
        return 1

# ––––––––––––––––––––––––––––––––

list1 = [] 

if enquiry(list1): 
    print ("The list isn't empty") 
else: 
    print("The list is Empty") 

# Result: "The list is Empty".

දෙවන ක්‍රමය more pythonicඑකකි. මෙම ක්‍රමය පරික්‍ෂා කිරීමේ ව්‍යාජ ක්‍රමයක් වන අතර එය පෙර ක්‍රමයට වඩා බෙහෙවින් යෝග්‍ය වේ.

def enquiry(list1): 
    if not list1: 
        return True
    else: 
        return False

# ––––––––––––––––––––––––––––––––

list1 = [] 

if enquiry(list1): 
    print ("The list is Empty") 
else: 
    print ("The list isn't empty") 

# Result: "The list is Empty"

මෙය උපකාරී වේ යැයි සිතමි.