Her zaman if not x is Nonesürümün daha net olduğunu düşündüm , ancak Google'ın stil kılavuzu ve PEP-8 her ikisi de kullanıyor if x is not None. Küçük bir performans farkı var mı (sanmıyorum) ve birinin gerçekten uymadığı bir durum var mı (diğerini sözleşmem için net bir kazanan yapıyor)? *

* Sadece değil, herhangi bir singleton'dan bahsediyorum None.

... Yok gibi tekilleri karşılaştırmak için. Kullanım öyle ya da değil.

Aynı bayt kodunu derlediklerinden hiçbir performans farkı yoktur:

Python 2.6.2 (r262:71600, Apr 15 2009, 07:20:39)
>>> import dis
>>> def f(x):
...    return x is not None
...
>>> dis.dis(f)
  2           0 LOAD_FAST                0 (x)
              3 LOAD_CONST               0 (None)
              6 COMPARE_OP               9 (is not)
              9 RETURN_VALUE
>>> def g(x):
...   return not x is None
...
>>> dis.dis(g)
  2           0 LOAD_FAST                0 (x)
              3 LOAD_CONST               0 (None)
              6 COMPARE_OP               9 (is not)
              9 RETURN_VALUE

Stilistik olarak kaçınmaya çalışırım not x is y. Derleyici her zaman bu şekilde davranmasına rağmen not (x is y), bir insan okuyucu yapıyı yanlış anlayabilir (not x) is y. Eğer x is not yyazarsam o zaman belirsizlik olmaz.

Hem Google hem de Python'un stil kılavuzu en iyi uygulamadır:

if x is not None:
    # Do something about x

Kullanmak not xistenmeyen sonuçlara neden olabilir.

Aşağıya bakınız:

>>> x = 1
>>> not x
False
>>> x = [1]
>>> not x
False
>>> x = 0
>>> not x
True
>>> x = [0]         # You don't want to fall in this one.
>>> not x
False

Python'da Trueveya FalsePython'da hangi değişmez değerlerin değerlendirildiğini görmek isteyebilirsiniz :

• Gerçek Değer Testi

Aşağıdaki yorum için düzenleyin:

Biraz daha test yaptım. önce not x is Noneolumsuz xve sonra ile karşılaştırıldığında None. Aslında, isoperatörün bu şekilde kullanıldığında daha yüksek bir önceliğe sahip olduğu görülmektedir :

>>> x
[0]
>>> not x is None
True
>>> not (x is None)
True
>>> (not x) is None
False

Bu nedenle, not x is Nonedürüst görüşüme göre, en iyi şekilde kaçınılmalıdır.

Daha fazla düzenleme:

Daha fazla test yaptım ve bukzor'un yorumunun doğru olduğunu onaylayabilirim. (En azından, başka türlü kanıtlayamadım.)

Bu demektir if x is not Noneki kesin sonuç olarak if not x is None. Ben düzeltilmiş duruyorum. Teşekkürler bukzor.

Ancak cevabım hala geçerli: Konvansiyonelif x is not None olanı kullanın .:]

Kod, önce programcı ve ikinci olarak derleyici veya yorumlayıcı tarafından anlaşılabilecek şekilde yazılmalıdır. "Değil" yapısı İngilizceyi "değil" den daha yakından andırır.

Python if x is not Noneveya if not x is None?

TLDR: Baytkodu derleyicisi ikisini de ayrıştırır x is not None- böylece okunabilirlik için kullanın if x is not None.

Okunabilirlik

Python'u kullanıyoruz çünkü insan tarafından okunabilirlik, kullanılabilirlik ve çeşitli programlama paradigmalarının performans üzerinde doğruluğu gibi şeylere değer veriyoruz.

Python, özellikle bu bağlamda okunabilirliği optimize eder.

Bayt Kodunu Ayrıştırma ve Derleme

not Daha zayıf bağlandığı daha is, bu nedenle burada mantıklı bir fark yoktur. Belgelere bakın :

İşleçler isve is notnesne kimliği testi: x is yyalnızca x ve y aynı nesne ise doğrudur. x is not yters doğruluk değeri verir.

is notÖzellikle Python içinde sağlanır dilbilgisi dil için bir okunabilirliği iyileştirme olarak:

comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'

Ve bu da dilbilgisinin üniter bir öğesidir.

Tabii ki, aynı ayrıştırılmaz:

>>> import ast
>>> ast.dump(ast.parse('x is not None').body[0].value)
"Compare(left=Name(id='x', ctx=Load()), ops=[IsNot()], comparators=[Name(id='None', ctx=Load())])"
>>> ast.dump(ast.parse('not x is None').body[0].value)
"UnaryOp(op=Not(), operand=Compare(left=Name(id='x', ctx=Load()), ops=[Is()], comparators=[Name(id='None', ctx=Load())]))"

Ama sonra bayt derleyici aslında çevirecek not ... isiçin is not:

>>> import dis
>>> dis.dis(lambda x, y: x is not y)
  1           0 LOAD_FAST                0 (x)
              3 LOAD_FAST                1 (y)
              6 COMPARE_OP               9 (is not)
              9 RETURN_VALUE
>>> dis.dis(lambda x, y: not x is y)
  1           0 LOAD_FAST                0 (x)
              3 LOAD_FAST                1 (y)
              6 COMPARE_OP               9 (is not)
              9 RETURN_VALUE

Bu nedenle, okunabilirlik ve dili amaçlandığı gibi kullanmak için lütfen kullanın is not.

Kullanmamak akıllıca değil .

Cevap, insanların yaptığı cevaptan daha basit.

Her iki şekilde de teknik bir avantajı yoktur ve "x y değildir" herkesin kullandığı şeydir , bu da onu açık kazanan yapar. "İngilizceye daha çok benziyor" ya da değil; herkes bunu kullanıyor, yani her Python kullanıcısı - yani dili Python hiçbir şeye benzemeyen Çinli kullanıcılar - biraz daha az yaygın sözdiziminin ayrıştırılması için birkaç ekstra beyin döngüsü alacağı bir bakışta anlayacak.

En azından bu alanda farklı olmak uğruna farklı olmayın.

is notOperatör sonucu ortadan fazla tercih edilir isbiçimsel nedenlerle. " if x is not None:" tıpkı İngilizce gibi okunur, ancak " if not x is None:" operatörün önceliğinin anlaşılmasını gerektirir ve İngilizce gibi okunmaz.

Bir performans farkı varsa, param açıktır is not, ancak bu kesinlikle bu tekniği tercih etme kararının motivasyonu değildir. Açıkçası uygulamaya bağlı olacaktır. Yana isgeçersiz kılınabilir değil, nasıl olsa herhangi bir ayrım dışarı optimize etmek kolay olmalıdır.

Şahsen ben kullanıyorum

if not (x is None):

Python sözdiziminde uzman olmayanlar bile her programcı tarafından belirsizlik olmadan hemen anlaşılır.

if not x is Nonediğer programlama dillerine daha benzer, ancak if x is not Nonekesinlikle daha net (ve İngilizce'de dilbilgisi açısından daha doğru) geliyor.

Bu benim için daha çok tercih edilen bir şey gibi göründüğünü söyledi.

x is not y Sonunda çok daha okunabilir kod üretmek için operatörlerin kod işleme önceliğini nasıl yazacağımı düşüneceğinden daha okunabilir formu tercih ederim .