1. assertYalnızca hata ayıklama amacıyla kullanmak yerine standart kodun bir parçası olarak kullanmakla ilgili bir performans veya kod bakımı sorunu var mı?

   Dır-dir

   assert x >= 0, 'x is less than zero'

   daha iyi veya daha kötü

   if x < 0:
       raise Exception, 'x is less than zero'

2. Ayrıca, if x < 0 raise errorher zaman olmadan kontrol edilir gibi bir iş kuralı belirlemenin herhangi bir yolu var mı try/except/finally, kod boyunca herhangi bir zamanda x0'dan küçükse assert x < 0, bir işlevin başlangıcında, işlevin herhangi bir yerinde ayarlanmış gibi bir hata ortaya çıkar. x0'dan küçük nerede istisna oluşur?

X fonksiyon boyunca sıfırdan küçük olduğunda otomatik olarak hata atabilme. Sınıf tanımlayıcılarını kullanabilirsiniz . İşte bir örnek:

class LessThanZeroException(Exception):
    pass

class variable(object):
    def __init__(self, value=0):
        self.__x = value

    def __set__(self, obj, value):
        if value < 0:
            raise LessThanZeroException('x is less than zero')

        self.__x  = value

    def __get__(self, obj, objType):
        return self.__x

class MyClass(object):
    x = variable()

>>> m = MyClass()
>>> m.x = 10
>>> m.x -= 20
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "my.py", line 7, in __set__
    raise LessThanZeroException('x is less than zero')
LessThanZeroException: x is less than zero

Ekler, asla olmaması gereken koşulları test etmek için kullanılmalıdır . Amaç, programın bozuk olması durumunda erken çökmektir.

Muhtemel olarak meydana gelebilecek hatalar için istisnalar kullanılmalı ve neredeyse her zaman kendi İstisna sınıflarınızı oluşturmalısınız .

Örneğin, bir yapılandırma dosyasından a'ya bir işlev okumak için bir işlev yazıyorsanız dict, dosyada yanlış biçimlendirme a değerini yükseltirken ConfigurationSyntaxError, assertgeri dönmek üzereyken yapabilirsiniz None.

Örneğinizde, xbir kullanıcı arayüzü veya harici bir kaynaktan ayarlanan bir değer varsa , bir istisna en iyisidir.

Eğer xsadece aynı programda kendi koduna göre ayarlanır, bir iddianın ile gitmek.

"assert" ifadeleri derleme optimize edildiğinde kaldırılır . Evet, hem performans hem de fonksiyonel farklılıklar var.

Derleme zamanında optimizasyon istendiğinde geçerli kod üreteci bir assert ifadesi için kod yayınlamaz. - Python 2 Dokümanları Python 3 Dokümanları

assertUygulama işlevselliğini uygulamak için kullanırsanız , dağıtımı üretime göre en iyi duruma getirirseniz, "ancak-in-works-in-dev" hatalarıyla karşılaşırsınız.

PYTHONOPTIMIZE ve -O -OO'ya bakın

Dört amacı assert

Dört meslektaşınız Alice, Bernd, Carl ve Daphne ile 200.000 satır kod üzerinde çalıştığınızı varsayın. Kodunuzu çağırıyorlar, kodlarını çağırıyorsunuz.

Sonra assertsahiptir dört rolleri :

1. Alice, Bernd, Carl ve Daphne'ye kodunuzun ne beklediğini bildirin.
   Bir tuples listesini işleyen bir yönteminiz olduğunu ve bu tuples değişmezse program mantığının kırılabileceğini varsayın:

   def mymethod(listOfTuples):
       assert(all(type(tp)==tuple for tp in listOfTuples))

   Bu, belgelerdeki eşdeğer bilgilerden daha güvenilirdir ve bakımı çok daha kolaydır.

2. Bilgisayara kodunuzun ne beklediğini bildirin.
   assertkodunuzun arayanlarından uygun davranışı uygular. Kodunuz Alices'in kodunu çağırırsa ve Bernd'ın kodu sizinkini çağırırsa assert, program Alices kodunda çökerse, Bernd bunun Alice'in hatası olduğunu varsayabilir, Alice araştırır ve sizin hatanız olduğunu varsayabilir, araştırırsınız ve Bernd'ın aslında olduğunu söylersiniz onun. Çok iş kaybettim.
   Bir çağrı yanlış yaparsa, iddialar ile hızlı bir şekilde sizin değil, onların hatası olduğunu görebilecekler. Alice, Bernd ve hepiniz faydalanıyorsunuz. Çok fazla zaman kazandırır.

3. Kodunuzu bir noktada (kendiniz de dahil) okuyucunuza bildirin.
   Girdilerin bir listesine sahip olduğunuzu ve her birinin temiz olabileceğini (hangisinin iyi olduğunu) veya smorsh, trale, gullup veya twinkled (hepsi kabul edilemez) olabileceğini varsayın. Eğer smorsh ise morsed olmamalıdır; trale ise baludoed olmalı; martı ise paçalanmalı (ve muhtemelen de tempolu olmalıdır); eğer parıldandıysa Perşembe günleri hariç yeniden parıldamalı. Fikri anlıyorsunuz: Bu karmaşık şeyler. Ancak sonuç, tüm girişlerin temiz olmasıdır (veya olması gerekir). Yapılacak doğru şey, temizleme döngünüzün etkisini şu şekilde özetlemektir:

   assert(all(entry.isClean() for entry in mylist))

   Bu ifadeler , harika döngünün tam olarak ne elde ettiğini anlamaya çalışan herkes için bir baş ağrısından kurtarır . Ve bu insanların en sık olanı muhtemelen kendiniz olacaksınız.

4. Bilgisayara bir noktada kodunuzun neler başardığını bildirin.
   Paça çıktıktan sonra buna ihtiyaç duyan bir girişi hızlandırmayı unutursanız assert, gününüzü kurtaracak ve kodunuzun kırılmasından çok daha fazla sevgili Daphne'nin kaçınmasını önleyeceksiniz.

Bana göre, assertiki dokümantasyon amacı (1 ve 3) ve koruma (2 ve 4) eşit derecede değerlidir.
İnsanları bilgilendirmek, bilgisayarı bilgilendirmekten bile daha değerli olabilir , çünkü assertyakalama amaçlarının (durum 1'de) çok yanlış olmasını ve her durumda sonraki hataların çoğunu önleyebilir .

Diğer cevaplara ek olarak, kendilerini istisnalar attığını iddia eder, ancak sadece AssertionErrors. Faydacı bir bakış açısından, hangi istisnaları yakaladığınız üzerinde ince taneli kontrole ihtiyaç duyduğunuzda iddialar uygun değildir.

Bu yaklaşımda gerçekten yanlış olan tek şey, iddia ifadelerini kullanarak çok açıklayıcı bir istisna yapmanın zor olmasıdır. Eğer daha basit sözdizimi için arıyorsanız, hatırlıyor olabilir ayrıca böyle bir şey yapmak:

class XLessThanZeroException(Exception):
    pass

def CheckX(x):
    if x < 0:
        raise XLessThanZeroException()

def foo(x):
    CheckX(x)
    #do stuff here

Başka bir sorun, normal durum denetimi için assert kullanmanın, -O bayrağını kullanarak hata ayıklama öğelerini devre dışı bırakmayı zorlaştırmasıdır.

İngilizce dil kelime assert burada anlamında kullanılır yemin , affirm , avow . "Çek" veya "olması gerektiği" anlamına gelmez . Bu demektir Eğer bir kodlayıcı olarak bir yapıyoruz yeminli ifade burda:

# I solemnly swear that here I will tell the truth, the whole truth, 
# and nothing but the truth, under pains and penalties of perjury, so help me FSM
assert answer == 42

Kod doğruysa, Tek olay uyaranlarını , donanım hatalarını ve benzerlerini engelleme , hiçbir onaylama başarısız olmaz . Bu nedenle programın son kullanıcıya olan davranışı etkilenmemelidir. Özellikle, bir iddia, istisnai programatik koşullar altında bile başarısız olamaz . Hiç olmadı. Böyle bir durumda, programcı bunun için zaptedilmelidir.

Daha önce de belirtildiği gibi, kodunuz hiç bir noktaya ÇIKMAMASI durumunda onaylar kullanılmalıdır, yani orada bir hata vardır. Bir iddiayı kullanmak için görebildiğim en yararlı neden muhtemelen değişmez / ön / son koşul. Bunlar, bir döngü veya işlevin her yinelemesinin başında veya sonunda doğru olması gereken bir şeydir.

Örneğin, özyinelemeli bir işlev (2 ayrı işlev, böylece 1 kötü girişi ve diğer kötü kodu işler, özyineleme ile ayırt etmek zorlaşır). Bu, if ifadesini yazmayı unutursam, neyin yanlış gittiğini açıklığa kavuşturacaktır.

def SumToN(n):
    if n <= 0:
        raise ValueError, "N must be greater than or equal to 0"
    else:
        return RecursiveSum(n)

def RecursiveSum(n):
    #precondition: n >= 0
    assert(n >= 0)
    if n == 0:
        return 0
    return RecursiveSum(n - 1) + n
    #postcondition: returned sum of 1 to n

Bu döngü değişmezleri genellikle bir iddia ile temsil edilebilir.

Mı bir performans sorunu var?

• Lütfen "hızlı çalışmasını sağlamadan önce çalışmasını sağlayın" .
  Herhangi bir programın yüzde çok azı genellikle hızı ile ilgilidir. assertBir performans sorunu olduğunu kanıtlarsa her zaman başlayabilir veya basitleştirebilirsiniz - ve çoğu asla olmayacaktır.

• Pragmatik olun :
  Boş olmayan bir tuples listesini işleyen bir yönteminiz olduğunu ve bu tuples değiştirilemezse program mantığının kırılacağını varsayın. Yazmalısınız:

  def mymethod(listOfTuples):
      assert(all(type(tp)==tuple for tp in listOfTuples))

  Listeleriniz on giriş uzunluğundaysa, bu muhtemelen iyidir, ancak bir milyon girişleri varsa sorun olabilir. Ancak bu değerli kontrolü tamamen atmak yerine,

  def mymethod(listOfTuples):
      assert(type(listOfTuples[0])==tuple)  # in fact _all_ must be tuples!

  Bu ucuz ama muhtemelen gerçek program hatalarının çoğunu yakalayacak .

Bu açık bir sorudur ve üzerinde durmak istediğim iki yönü var: ne zaman iddialar ekleyeceğim ve hata mesajlarını nasıl yazacağım.

amaç

Bunu yeni başlayanlara açıklamak - iddialar hataları artırabilecek ifadelerdir, ancak onları yakalamayacaksınız. Ve normalde yetiştirilmemelidirler, ancak gerçek hayatta bazen yine de kaldırılırlar. Ve bu, 'ölümcül hata' dediğimiz kodun kurtarılamadığı ciddi bir durumdur.

Daha sonra, doğru olsa da çok küçümseyici olan 'hata ayıklama amaçları' içindir. Farklı yeni başlayanlarda farklı şekilde çalışmasına rağmen 'asla ihlal edilmemesi gereken' formülasyonu daha iyi tanımlamamı seviyorum ... Bazıları 'sadece olsun' ve diğerleri bunun için herhangi bir fayda bulamıyor veya normal istisnaları değiştiriyor, hatta akışını bile kontrol edebilir.

stil

Python'da assertbir ifade değil, bir işlevdir! (hatırlamayacaksınız assert(False, 'is true'). Ama bunu yoldan çıkarmak:

İsteğe bağlı 'hata mesajı' ne zaman ve nasıl yazılır?

Bu acually sık (iddialarını yapmak için birçok özel yöntemleri var ünite test çerçeveler için geçerlidir assertTrue(condition), assertFalse(condition), assertEqual(actual, expected)vs.). Ayrıca, genellikle iddiayı yorumlamak için bir yol sağlarlar.

Uzaklaştırma kodunda hata mesajları olmadan yapabilirsiniz.

Bazı durumlarda, iddiaya eklenecek hiçbir şey yoktur:

def dökümü (bir şey): iddia isinstance (bir şey, Dumpable) # ...

Ancak bunun dışında, bir mesaj diğer programcılarla (bazen kodunuzun etkileşimli kullanıcıları olan, örneğin Ipython / Jupyter vb.) İletişim için yararlıdır.

Onlara sadece iç uygulama ayrıntılarını sızdırmayan bilgiler verin.

onun yerine:

assert meaningless_identifier <= MAGIC_NUMBER_XXX, 'meaningless_identifier is greater than MAGIC_NUMBER_XXX!!!'

yazmak:

assert meaningless_identifier > MAGIC_NUMBER_XXX, 'reactor temperature above critical threshold'

hatta belki:

assert meaningless_identifier > MAGIC_NUMBER_XXX, f'reactor temperature({meaningless_identifier }) above critical threshold ({MAGIC_NUMBER_XXX})'

Biliyorum, biliyorum - bu statik bir iddia için bir durum değil, ama mesajın bilgi değerine işaret etmek istiyorum.

Olumsuz mu, olumlu mesaj mı?

Bu tartışmalı olabilir, ancak aşağıdaki gibi şeyleri okumak bana acı veriyor:

assert a == b, 'a is not equal to b'

• bunlar birbirinin yanında yazılan iki çelişkili şeydir. Kod tabanı üzerinde her bir etkiye sahip olduğumda, ne istemediğimizi belirtmek için 'zorunluluk' ve 'zorunluluk' gibi ekstra fiiller kullanarak ne istediğimizi belirtmeye çalışırım.

  a == b, 'a b'ye eşit olmalı'

Daha sonra, alma AssertionError: a must be equal to bda okunabilir ve ifade kodda mantıklı görünür. Ayrıca, geri izlemeyi okumadan bir şey elde edebilirsiniz (hatta bazen mevcut olmayabilir).

Hem assertistisnaların kullanımı hem de istisnaları iletişim ile ilgilidir.

• İddialar , geliştiricilere yönelik kodun doğruluğuna ilişkin ifadelerdir : Koddaki bir iddia, kodun doğru olması için yerine getirilmesi gereken koşullar hakkında okuyucuyu kodu bilgilendirir. Çalışma zamanında başarısız olan bir iddia, geliştiricilere kodda düzeltilmesi gereken bir hata olduğunu bildirir.

• İstisnalar, çalışma zamanında meydana gelebilecek ancak orada işlenecek çağrı kodunda ele alınan, kod tarafından çözülemeyen tipik olmayan durumlarla ilgili göstergelerdir. Bir istisna oluşması, kodda bir hata olduğunu göstermez.

En iyi pratik

Bu nedenle, çalışma zamanında belirli bir durumun ortaya çıkmasını geliştiricilere ("Merhaba geliştirici, bu koşul bir yerde bir hata olduğunu gösterir, lütfen kodu düzeltin.") Bildirmek istediğiniz bir hata olarak görürseniz. bir iddiaya varmak. İddia kodunuzun giriş argümanlarını kontrol ederse, giriş argümanları bu koşulları ihlal ettiğinde tipik olarak kodunuzun "tanımlanmamış davranış" olduğunu belgelemelisiniz.

Bunun yerine, bu durumun ortaya çıkması gözlerinizdeki bir hatanın göstergesi değilse, bunun yerine müşteri kodu tarafından ele alınması gerektiğini düşündüğünüz (belki nadir ancak) olası bir durum, bir istisna oluşturur. İstisnanın ortaya çıktığı durumlar, ilgili kodun belgelerinin bir parçası olmalıdır.

Kullanırken bir performans [...] sorunu var mı assert

İddiaların değerlendirilmesi biraz zaman alır. Ancak derleme zamanında elimine edilebilirler. Ancak bunun bazı sonuçları vardır, aşağıya bakınız.

Kullanırken [...] kod bakım sorunu var mı assert

Normalde iddialar, varsayımları açık hale getirerek ve çalışma sırasında bu varsayımları düzenli olarak doğrulayarak okunabilirliği geliştirdiği için kodun sürdürülebilirliğini artırır. Bu aynı zamanda regresyonları yakalamaya yardımcı olacaktır. Ancak akılda tutulması gereken bir konu var: İddialarda kullanılan ifadelerin yan etkileri olmamalıdır. Yukarıda belirtildiği gibi, derlemeler sırasında iddialar ortadan kaldırılabilir - bu da potansiyel yan etkilerin ortadan kalkacağı anlamına gelir. Bu - istemeden - kodun davranışını değiştirebilir.

Assert aşağıdakileri kontrol etmektir:
1. geçerli koşul,
2. geçerli ifade,
3. gerçek mantık;
kaynak kodu. Tüm projenin başarısız olması yerine, kaynak dosyanızda bir şeyin uygun olmadığı konusunda bir alarm verir.

Örnek 1'de, 'str' değişkeni boş olmadığından. Dolayısıyla hiçbir iddia ya da istisna ortaya çıkmaz.

Örnek 1:

#!/usr/bin/python

str = 'hello Python!'
strNull = 'string is Null'

if __debug__:
    if not str: raise AssertionError(strNull)
print str

if __debug__:
    print 'FileName '.ljust(30,'.'),(__name__)
    print 'FilePath '.ljust(30,'.'),(__file__)


------------------------------------------------------

Output:
hello Python!
FileName ..................... hello
FilePath ..................... C:/Python\hello.py

Örnek 2'de var 'str' boştur. Bu yüzden kullanıcıyı iddia beyanı ile hatalı programın önüne geçmekten kurtarıyoruz .

Örnek 2:

#!/usr/bin/python

str = ''
strNull = 'NULL String'

if __debug__:
    if not str: raise AssertionError(strNull)
print str

if __debug__:
    print 'FileName '.ljust(30,'.'),(__name__)
    print 'FilePath '.ljust(30,'.'),(__file__)


------------------------------------------------------

Output:
AssertionError: NULL String

Hata ayıklama istemediğimiz ve kaynak koddaki onaylama sorununu gerçekleştirdiğimiz an. Optimizasyon bayrağını devre dışı bırak

python -O assertStatement.py
hiçbir şey yazdırılmayacak

PTVS, PyCharm, Wing assert isinstance()ifadeleri gibi IDE'lerde, bazı belirsiz nesneler için kod tamamlamayı etkinleştirmek üzere kullanılabilir.

Değeri ne olursa olsun, assertdüzgün çalışmaya dayanan bir kodla uğraşıyorsanız , aşağıdaki kodu eklemek, eklerin etkinleştirilmesini sağlayacaktır:

try:
    assert False
    raise Exception('Python assertions are not working. This tool relies on Python assertions to do its job. Possible causes are running with the "-O" flag or running a precompiled (".pyo" or ".pyc") module.')
except AssertionError:
    pass