Python'da “assert” kullanımı nedir?

Bazı kaynak kodlarını okudum ve bazı yerlerde kullanımını gördüm assert.

Tam olarak ne anlama geliyor? Kullanımı nedir?

Bu assertifade neredeyse her programlama dilinde mevcuttur. Daha sonra başka bir işlemin yan etkisi olarak değil, sorunun açık olduğu programınızın başlangıcındaki sorunları algılamaya yardımcı olur.

Bunu yaptığınızda ...

assert condition

... programa bu koşulu test etmesini söylüyorsunuz ve koşul yanlışsa derhal bir hata tetikliyorsunuz.

Python'da kabaca buna eşittir:

if not condition:
    raise AssertionError()

Python kabuğunda deneyin:

>>> assert True # nothing happens
>>> assert False
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

Onaylar isteğe bağlı bir mesaj içerebilir ve yorumlayıcıyı çalıştırırken bunları devre dışı bırakabilirsiniz.

Onaylama başarısız olursa bir mesajı yazdırmak için:

assert False, "Oh no! This assertion failed!"

Do not çağırmak için parantez kullanmak assertbir işlev gibi. Bu bir ifadedir. Bunu yaparsanız , ilk parametre olarak bir tuple ile assert(condition, message)çalışacaksınız .assert(condition, message)

Çalıştırırken, onları devre dışı bırakmayı gelince pythonoptimize modunda __debug__ise False, assert ifadeleri dikkate alınmaz. Sadece -Obayrağı geç:

python -O script.py

İlgili belgeler için buraya bakın .

Parantezlere dikkat edin. Yukarıda da belirtildiği gibi, Python 3'te asserthala bir ifade vardır , bu yüzden ile benzer şekilde print(..), kişi aynı şeyi assert(..)veya için tahmin edebilir, raise(..)ancak yapmamalısınız.

Bu önemlidir çünkü:

assert(2 + 2 == 5, "Houston we've got a problem")

aksine, çalışmayacak

assert 2 + 2 == 5, "Houston we've got a problem"

Birincisinin işe yaramamasının nedeni, bool( (False, "Houston we've got a problem") )değerlendirmektir True.

İfadede assert(False), bunlar sadece Falseiçeriklerini değerlendiren gereksiz parantezler . Ancak assert(False,)parantezler artık bir demettir ve boş olmayan bir demet Trueboole bağlamında değerlendirilir .

Diğer cevapların belirttiği gibi, assertbelirli bir koşul doğru değilse bir istisna atmaya benzer. Önemli bir fark, kodunuzu optimizasyon seçeneğiyle derlerseniz assert ifadelerinin yok sayılmasıdır -O. Dokümantasyon söylüyor assert expressiondaha iyi eşdeğer olarak tarif edilebilir

if __debug__:
   if not expression: raise AssertionError

Kodunuzu kapsamlı bir şekilde test etmek, ardından onaylama durumlarınızın hiçbirinin başarısız olmamasından memnun olduğunuzda optimize edilmiş bir sürüm yayınlamak istiyorsanız bu yararlı olabilir - optimizasyon açıkken __debug__değişken Yanlış olur ve koşullar değerlendirilmeyi durduracaktır. Bu özellik, eklere güveniyorsanız ve kaybolduklarının farkında değilseniz sizi de yakalayabilir.

Python'daki bir iddianın amacı, geliştiricileri bir programdaki kurtarılamaz hatalar hakkında bilgilendirmektir .

Onaylamaların, kullanıcının düzeltici eylemde bulunabileceği (veya yalnızca tekrar deneyebileceği) “dosya bulunamadı” gibi beklenen hata durumlarını göstermesi amaçlanmamıştır.

Buna bakmanın bir başka yolu, iddiaların kodunuzda dahili öz denetimler olduğunu söylemektir . Bazı koşulları kodunuzda imkansız olarak ilan ederek çalışırlar . Bu koşullar geçerli değilse, programda bir hata olduğu anlamına gelir.

Programınız hatasızsa, bu koşullar hiçbir zaman gerçekleşmez. Ancak bunlardan biri meydana gelirse, program size tam olarak hangi “imkansız” durumun tetiklendiğini söyleyen bir iddiayla hata verecektir. Bu, programlarınızdaki hataları izlemeyi ve düzeltmeyi çok daha kolay hale getirir.

İşte yazdığım Python'un iddialarına dair bir öğreticiden bir özet :

Python'un assert ifadesi, çalışma zamanı hatalarını ele almak için bir mekanizma değil, bir hata ayıklama yardımcısıdır. İddiaları kullanmanın amacı, geliştiricilerin bir hatanın olası temel nedenini daha hızlı bulmasını sağlamaktır. Programınızda bir hata olmadığı sürece bir onaylama hatası asla yükseltilmemelidir.

Diğerleri zaten belgelere bağlantılar vermiştir.

Etkileşimli bir kabukta aşağıdakileri deneyebilirsiniz:

>>> assert 5 > 2
>>> assert 2 > 5
Traceback (most recent call last):
  File "<string>", line 1, in <fragment>
builtins.AssertionError:

İlk ifade hiçbir şey yapmaz, ikincisi ise bir istisna oluşturur. Bu ilk ipucudur: varsayımlar, kodunuzun belirli bir pozisyonunda (genellikle, başlangıç ​​(ön koşullar) ve bir fonksiyonun sonu (son koşullar)) doğru olması gereken koşulları kontrol etmek için yararlıdır.

Ekler aslında çok kullanışlı bir mühendislik uygulaması olan sözleşmeyle programlamaya son derece bağlıdır:

http://en.wikipedia.org/wiki/Design_by_contract .

Dokümanlar'dan:

Assert statements are a convenient way to insert debugging assertions into a program

Buradan daha fazlasını okuyabilirsiniz: http://docs.python.org/release/2.5.2/ref/assert.html

Assert ifadesinin iki şekli vardır.

Basit bir şekilde, assert <expression>denktir

if __​debug__:
    if not <expression>: raise AssertionError

Uzatılmış biçim assert <expression1>, <expression2>, eşdeğerdir

if __​debug__:
    if not <expression1>: raise AssertionError, <expression2>

İddialar, bir programın dahili durumunun, programcı tarafından beklendiği gibi, hataları yakalamak amacıyla kontrol edilmesinin sistematik bir yoludur. Aşağıdaki örneğe bakın.

>>> number = input('Enter a positive number:')
Enter a positive number:-1
>>> assert (number > 0), 'Only positive numbers are allowed!'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: Only positive numbers are allowed!
>>> 

İşte basit bir örnek, bunu dosyaya kaydedin (diyelim ki b.py)

def chkassert(num):
    assert type(num) == int


chkassert('a')

ve sonuç ne zaman $python b.py

Traceback (most recent call last):
  File "b.py", line 5, in <module>
    chkassert('a')
  File "b.py", line 2, in chkassert
    assert type(num) == int
AssertionError

onaylamadan sonraki ifade doğruysa program devam eder, ancak onaylamadan sonraki ifade yanlışsa program hata verir. Bu kadar basit.

Örneğin:

assert 1>0   #normal execution
assert 0>1   #Traceback (most recent call last):
             #File "<pyshell#11>", line 1, in <module>
             #assert 0>1
             #AssertionError

Bu assertifade neredeyse her programlama dilinde mevcuttur. Daha sonra başka bir işlemin yan etkisi olarak değil, sorunun açık olduğu programınızın başlangıcındaki sorunları algılamaya yardımcı olur. Her zaman bir Truedurum beklerler .

Gibi bir şey yaptığınızda:

assert condition

Programa bu durumu test etmesini ve yanlışsa hemen bir hatayı tetiklemesini söylüyorsunuz.

Python'da assertifade , şuna eşittir:

if __debug__:
    if not <expression>: raise AssertionError

İsteğe bağlı bir iletiyi iletmek için genişletilmiş ifadeyi kullanabilirsiniz :

if __debug__:
    if not (expression_1): raise AssertionError(expression_2)

Python yorumlayıcısında deneyin:

>>> assert True # Nothing happens because the condition returns a True value.
>>> assert False # A traceback is triggered because this evaluation did not yield an expected value.
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

Esas olarak assertve ififadeleri arasında geçiş yapmayı düşünenler için bunları kullanmadan önce görülmesi gereken bazı uyarılar vardır . Kullanım amacı assert, programın bir durumu doğrulaması ve hatayı atlamak için alternatif bir yol almak yerine programı hemen durdurması gereken bir değer döndürmesi durumudur:

1. Parantezler

Fark etmiş olabileceğiniz gibi, assertifade iki koşul kullanır. Dolayısıyla, do not bariz tavsiye için biri olarak bunları englobe için parantezleri kullanabilirsiniz. Böyle yaparsanız:

assert (condition, message)

Misal:

>>> assert (1==2, 1==1)
<stdin>:1: SyntaxWarning: assertion is always true, perhaps remove parentheses?

İlk parametre olarak bir tuple temsil eden bir assertile çalışacaksınız (condition, message)ve bu Python'da boş olmayan tuple her zaman olduğu için olurTrue . Ancak, sorunsuz olarak ayrı ayrı yapabilirsiniz:

assert (condition), "message"

Misal:

>>> assert (1==2), ("This condition returns a %s value.") % "False"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: This condition returns a False value.

2. Hata ayıklama amacı

Eğer ne zaman kullanım assertifadesi merak ediyorsanız . Gerçek hayatta kullanılan bir örnek alın:

* Programınız kullanıcı tarafından girilen her bir parametreyi veya başka bir şeyi kontrol etme eğiliminde olduğunda:

def loremipsum(**kwargs):
    kwargs.pop('bar') # return 0 if "bar" isn't in parameter
    kwargs.setdefault('foo', type(self)) # returns `type(self)` value by default
    assert (len(kwargs) == 0), "unrecognized parameter passed in %s" % ', '.join(kwargs.keys())

* Başka bir durum, 0 olduğunda veya belirli bir denklemde katsayı veya sabit olarak pozitif olmadığında matematik üzerindedir:

def discount(item, percent):
    price = int(item['price'] * (1.0 - percent))
    print(price)
    assert (0 <= price <= item['price']),\
            "Discounted prices cannot be lower than 0 "\
            "and they cannot be higher than the original price."

    return price

* veya basit bir boole uygulamasına örnek:

def true(a, b):
    assert (a == b), "False"
    return 1

def false(a, b):
    assert (a != b), "True"
    return 0

3. Veri işleme veya veri doğrulama

assertVeri işlemeyi veya veri doğrulamayı yürütmek için ifadeye güvenmemek son derece önemlidir, çünkü bu ifade sırasıyla Python başlatma -Oveya -OObayrak - yani değer 1, 2 ve 0 (varsayılan olarak) veya PYTHONOPTIMIZEortam değişkeni ile kapatılabilir - ortam değişkeni .

Değer 1:

* iddialar devre dışıdır;

* Derlenen dosyalar kullanılarak oluşturulan .pyouzantısı yerine .pyc;

* sys.flags.optimize1 ( True) olarak ayarlanmıştır ;

* Ve, __debug__olarak ayarlanır False;

Değer 2: bir şeyi daha devre dışı bırakır

* docstrings devre dışı;

Bu nedenle, assertbir tür beklenen veriyi doğrulamak için ifadeyi kullanmak son derece tehlikelidir, bu da bazı güvenlik sorunlarına bile işaret eder. Ardından, bazı izinleri doğrulamanız gerekiyorsa raise AuthErrorbunun yerine size tavsiye ederim . Bir ön koşullu etki olarak, assertbir kullanıcı doğrudan etkileşimde bulunmayan kütüphaneler veya modüller üzerinde programcılar tarafından yaygın olarak kullanılır.

C2 Wiki'de kısaca özetlendiği gibi :

Bir iddia, programda belirli bir noktadaki bir boolean ifadesidir ve programda bir hata olmadığı sürece geçerli olacaktır .

assertBelirli bir program noktasında kodu anladığınızı belgelemek için bir ifade kullanabilirsiniz . Örneğin, girdiler (önkoşullar), program durumu (değişmezler) veya çıktılar (postkoşullar) ile ilgili varsayımları veya garantileri belgeleyebilirsiniz.

İddianız başarısız olursa, bu sizin (veya halefinizin) programı yazarken yanlış anladığınız ve muhtemelen bir hata içerdiğine dair bir uyarıdır.

Daha fazla bilgi için, John Regehr'in Python ifadesi için de geçerli olan İddiaların Kullanımı hakkında harika bir blog yazısı var assert.

Ayrılmış bir işlevin python'da tam olarak ne yaptığını bilmek istiyorsanız, help(enter_keyword)

Ayrılmış bir anahtar kelimeyi girdiğinizden emin olun ve bunu dize olarak girin.

Python iddiası temel olarak kodunuzun dahili kendi kendine kontrolü için koşulu test eden bir hata ayıklama yardımcısıdır. Assert, kodunuz imkansız uç durumlara girdiğinde hata ayıklamayı gerçekten kolaylaştırır. Bu imkansız durumları kontrol edin.

Diyelim ki indirimden sonra ürünün fiyatını hesaplamak için bir işlev var:

def calculate_discount(price, discount):
    discounted_price = price - [discount*price]
    assert 0 <= discounted_price <= price
    return discounted_price

Burada, indirimli_fiyat asla 0'dan küçük ve gerçek fiyattan daha büyük olamaz. Dolayısıyla, yukarıdaki koşulun ihlal edilmesi durumunda, iddia, geliştiricinin imkansız bir şey olduğunu tanımlamasına yardımcı olan bir Onaylama Hatası oluşturur.

Umarım yardımcı olur :)

Kısa açıklamam:

• assertAssertionErrorifade yanlışsa yükseltir , aksi takdirde sadece kod devam eder ve ne olursa olsun virgül varsa AssertionError: whatever after commave kod şuna benzer:raise AssertionError(whatever after comma)

Bununla ilgili bir öğretici:

https://www.tutorialspoint.com/python/assertions_in_python.htm

Pycharm'da, assertbirlikte kullanıyorsanızisinstance bir nesnenin türünü bildirmek için kullanırsanız, kodlama sırasında üst nesnenin yöntemlerine ve özniteliklerine erişmenize izin verir, otomatik olarak tamamlanır.

Örneğin self.object1.object2, bir MyClassnesne olduğunu varsayalım.

import MyClasss

def code_it(self):
    testObject = self.object1.object2 # at this point, program doesn't know that testObject  is a MyClass object yet
    assert isinstance(testObject , MyClasss) # now the program knows testObject is a MyClass object
    testObject.do_it() # from this point on, PyCharm will be able to auto-complete when you are working on testObject

Diğer cevaplarda yazıldığı gibi, assert ifadeler belirli bir noktada programın durumunu kontrol etmek için kullanılır.

İlişkili mesaj, parantez veya -Oseçenek ve __debug__sabit hakkında söylenenleri tekrar etmeyeceğim . İlk elden bilgi için dokümanı da kontrol edin . Sorunuza odaklanacağım: ne işe yarar assert? Daha kesin olarak, ne zaman (ve ne zaman değil) kullanılmalıdır assert?

assertİfadeleri bir program hata ayıklamak için faydalıdır, fakat kullanıcı girişi kontrol etmek cesaretini. Ben aşağıdaki kural kullanın: Bu bir durum olmamalı tespit etmek için iddiaları tutmak . Bir kullanıcı girişi yanlış olabilir, örneğin bir şifre çok kısa, ancak bu bir durum olmamalıdır . Bir dairenin çapı yarıçapından iki kat daha büyük değilse, bu durumda olmalısınız .

En ilginç olanı assert, beynimin kullanımı, B. Meyer tarafından [Nesne Odaklı Yazılım İnşası] 'nda açıklanan sözleşme ile programlamadan esinlenmiştir ( https://www.eiffel.org/doc/eiffel/Object-Oriented_Software_Construction% 2C_2nd_Edition ) ve [Eiffel programlama dili] 'nde ( https://en.wikipedia.org/wiki/Eiffel_(programming_language ) uygulanmaktadır. İfadeyi kullanarak programlamayı sözleşmeyle tam olarak taklit edemezsiniz assert, ancak niyeti korumak ilginçtir.

İşte bir örnek. Bir headişlev yazmanız gerektiğini düşünün ([ headHaskell'deki işlev gibi ) ( http://www.zvon.org/other/haskell/Outputprelude/head_f.html ). Belirtilen özellikler: "liste boş değilse, listenin ilk öğesini döndür". Aşağıdaki uygulamalara bakın:

>>> def head1(xs): return xs[0]

Ve

>>> def head2(xs):
...     if len(xs) > 0:
...         return xs[0]
...     else:
...         return None

_{(Evet, bu şu şekilde yazılabilir return xs[0] if xs else None, ama mesele bu değil)} .

Liste boş değilse, her iki işlev de aynı sonuca sahiptir ve bu sonuç doğrudur:

>>> head1([1, 2, 3]) == head2([1, 2, 3]) == 1
True

Dolayısıyla, her iki uygulama da (umarım) doğrudur. Boş bir listenin baş öğesini almaya çalıştığınızda farklıdırlar:

>>> head1([])
Traceback (most recent call last):
...
IndexError: list index out of range

Fakat:

>>> head2([]) is None
True

Yine, her iki uygulama da doğrudur, çünkü kimse bu işlevlere boş bir liste iletmemelidir ( spesifikasyonun dışındayız ). Bu yanlış bir çağrıdır, ancak böyle bir çağrı yaparsanız her şey olabilir. Bir işlev bir istisna oluşturur, diğeri özel bir değer döndürür. En önemlisi: bu davranışa güvenemeyiz . Eğer xsboş, işe yarayacak:

print(head2(xs))

Ancak bu programın çökmesine neden olacaktır:

print(head1(xs))

Bazı sürprizlerden kaçınmak için, bir işleve beklenmedik bir argüman aktardığımda bilmek isterim. Başka bir deyişle: Gözlenebilir davranışın ne zaman güvenilir olmadığını bilmek istiyorum, çünkü spesifikasyona değil uygulamaya bağlıdır. Tabii ki, özellikleri okuyabilirim, ancak programcılar her zaman belgeleri dikkatlice okumaz.

Aşağıdaki etkiyi elde etmek için koda şartname eklemek için bir yol olsaydı düşünün: şartnameyi ihlal ettiğimde, örneğin boş bir liste geçirerek head, bir uyarı alıyorum. Bu, doğru (yani şartnameye uygun) bir program yazmak için çok yardımcı olacaktır. Ve işte assert sahneye giriyor:

>>> def head1(xs):
...     assert len(xs) > 0, "The list must not be empty"
...     return xs[0]

Ve

>>> def head2(xs):
...     assert len(xs) > 0, "The list must not be empty"
...     if len(xs) > 0:
...         return xs[0]
...     else:
...         return None

Şimdi, elimizde:

>>> head1([])
Traceback (most recent call last):
...
AssertionError: The list must not be empty

Ve:

>>> head2([])
Traceback (most recent call last):
...
AssertionError: The list must not be empty

Not head1bir atar AssertionError, bir değil IndexError. Bu önemlidir çünkü a herhangi bir çalışma zamanı hatası AssertionErrordeğildir : spesifikasyonun ihlal edildiğine işaret eder. Bir uyarı istedim ama bir hata alıyorum. Neyse ki, kontrolü ( seçeneği kullanarak ) devre dışı bırakabilirim , ancak kendi risklerim altında. Bunu yapacağım bir kaza gerçekten pahalı ve en iyisini umuyorum. Programımın bir kara delikten geçen bir uzay gemisine gömüldüğünü düşünün. İddiaları devre dışı bırakacağım ve programın mümkün olduğunca uzun süre çökmeyecek kadar sağlam olduğunu umuyorum.-O

Bu örnek yalnızca önkoşullarla ilgiliydi, ancak assertpostconditions'ı (dönüş değeri ve / veya durum) ve değişmezleri (bir sınıfın durumu) kontrol etmek için kullanabilirsiniz . Koşulları ve değişmezleri kontrol etmenin asserthantal olabileceğini unutmayın :

• son koşullar için, bir değişkene dönüş değeri atamanız ve belki de bir yöntemle uğraşıyorsanız nesnenin iniial durumunu saklamanız gerekir;
• değişmezler için, bir yöntem çağrısından önce ve sonra durumu kontrol etmeniz gerekir.

Eiffel kadar sofistike bir şeye sahip olmayacaksınız, ancak bir programın genel kalitesini artırabilirsiniz.

Özetlemek gerekirse, bu assertbir durumun olmaması gereken durumları tespit etmek için uygun bir yoldur . Şartnamenin ihlalleri (örneğin boş bir listenin geçilmesi head) birinci sınıftır, bu olmamalıdır . Bu nedenle, assertifade beklenmedik bir durumu tespit etmek için kullanılabilse de, spesifikasyonun yerine getirilmesini sağlamak ayrıcalıklı bir yoldur. assertKodu belirtmek üzere ifadeye ekledikten sonra , yanlış argümanlar, yanlış dönüş değerleri, bir sınıfın yanlış durumları ... rapor edileceği için programın kalitesini iyileştirdiğinizi umuyoruz.

format: assert İfade [, bağımsız değişkenler] Assert bir ifadeyle karşılaştığında, Python ifadeyi değerlendirir. İfade doğru değilse bir istisna ortaya çıkar (assertionError). Onaylama başarısız olursa Python, AssertionError için bağımsız değişken olarak ArgumentExpression kullanır. AssertionError istisnaları, try-hariç ifadesi kullanılarak diğer istisnalar gibi yakalanabilir ve işlenebilir, ancak işlenmezse programı sonlandıracak ve bir geri izleme üretecektir. Misal:

def KelvinToFahrenheit(Temperature):    
    assert (Temperature >= 0),"Colder than absolute zero!"    
    return ((Temperature-273)*1.8)+32    
print KelvinToFahrenheit(273)    
print int(KelvinToFahrenheit(505.78))    
print KelvinToFahrenheit(-5)    

Yukarıdaki kod yürütüldüğünde aşağıdaki sonucu verir:

32.0
451
Traceback (most recent call last):    
  File "test.py", line 9, in <module>    
    print KelvinToFahrenheit(-5)    
  File "test.py", line 4, in KelvinToFahrenheit    
    assert (Temperature >= 0),"Colder than absolute zero!"    
AssertionError: Colder than absolute zero!    

def getUser(self, id, Email):

    user_key = id and id or Email

    assert user_key

Fonksiyon çağrısında parametrelerin iletildiğinden emin olmak için kullanılabilir.

>>>this_is_very_complex_function_result = 9
>>>c = this_is_very_complex_function_result
>>>test_us = (c < 4)

>>> #first we try without assert
>>>if test_us == True:
    print("YES! I am right!")
else:
    print("I am Wrong, but the program still RUNS!")

I am Wrong, but the program still RUNS!


>>> #now we try with assert
>>> assert test_us
Traceback (most recent call last):
  File "<pyshell#52>", line 1, in <module>
    assert test_us
AssertionError
>>> 

Temel olarak assert anahtar kelime anlamı, eğer koşul doğru değilse, o zaman başka bir iddia hatasıyla, örneğin python'da devam etmesidir.

Kod-1

a=5

b=6

assert a==b

ÇIKTI:

assert a==b

AssertionError

Kod-2

a=5

b=5

assert a==b

ÇIKTI:

Process finished with exit code 0