Do czego służy „aser” w Pythonie?

Czytałem jakiś kod źródłowy i w kilku miejscach widziałem użycie assert.

Co to dokładnie znaczy? Jakie jest jego użycie?

assertOświadczenie istnieje w prawie każdym języku programowania. Pomaga wykryć problemy na wczesnym etapie programu, gdzie przyczyna jest wyraźna, a nie później jako efekt uboczny innej operacji.

Kiedy to zrobisz ...

assert condition

... każesz programowi przetestować ten warunek i natychmiast wywołać błąd, jeśli warunek jest fałszywy.

W Pythonie odpowiada to mniej więcej tak:

if not condition:
    raise AssertionError()

Wypróbuj w powłoce Pythona:

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

Asercje mogą zawierać opcjonalny komunikat i można je wyłączyć podczas uruchamiania interpretera.

Aby wydrukować wiadomość, jeśli asercja się nie powiedzie:

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

Czy nie używać nawiasów, aby wywołać assertjak funkcja. To jest oświadczenie. Jeśli to zrobisz assert(condition, message), uruchomisz assertz (condition, message)krotką jako pierwszym parametrem.

Jeśli chodzi o ich wyłączanie, podczas działania pythonw trybie zoptymalizowanym, gdzie __debug__jest False, instrukcje aser będą ignorowane. Wystarczy przekazać -Oflagę:

python -O script.py

Zobacz tutaj odpowiednią dokumentację.

Uważaj na nawiasy. Jak już wspomniano powyżej, w Pythonie 3 assertnadal znajduje się stwierdzenie , więc analogicznie do print(..), można ekstrapolować to samo assert(..)lub raise(..)nie należy.

Jest to ważne, ponieważ:

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

nie zadziała, w przeciwieństwie do

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

Pierwszym powodem, dla którego pierwszy nie zadziała, jest bool( (False, "Houston we've got a problem") )ocena True.

W oświadczeniu assert(False)są to po prostu nadmiarowe nawiasy wokół False, które oceniają ich zawartość. Ale z assert(False,)nawiasami są teraz krotki, a niepuste krotki mają Truewartość logiczną.

Jak zauważyły ​​inne odpowiedzi, assertprzypomina rzucanie wyjątku, jeśli dany warunek nie jest spełniony. Ważną różnicą jest to, że instrukcje aser są ignorowane, jeśli skompilujesz kod z opcją optymalizacji -O. Dokumentacja mówi, że assert expressionmoże być lepiej opisane jako równoważne

if __debug__:
   if not expression: raise AssertionError

Może to być przydatne, jeśli chcesz dokładnie przetestować swój kod, a następnie wydać wersję zoptymalizowaną, gdy będziesz zadowolony, że żadna z twoich asercji nie zawiodła - gdy optymalizacja jest włączona, __debug__zmienna staje się False i warunki przestają być oceniane. Ta funkcja może Cię również złapać, jeśli polegasz na twierdzeniach i nie zdajesz sobie sprawy, że zniknęły.

Celem asercji w Pythonie jest informowanie programistów o niemożliwych do naprawienia błędach w programie.

Asercje nie są przeznaczone do sygnalizowania oczekiwanych warunków błędu, takich jak „nie znaleziono pliku”, w których użytkownik może podjąć działania naprawcze (lub po prostu spróbować ponownie).

Innym sposobem na to jest stwierdzenie, że asercje są wewnętrznymi samokontrolami w twoim kodzie. Działają, deklarując niektóre warunki jako niemożliwe w twoim kodzie. Jeśli te warunki się nie utrzymają, oznacza to błąd w programie.

Jeśli twój program nie zawiera błędów, te warunki nigdy nie wystąpią. Ale jeśli wystąpi jeden z nich , program ulegnie awarii z błędem asercji, informującym dokładnie, który warunek „niemożliwy” został wywołany. Dzięki temu znacznie łatwiej jest wyśledzić i naprawić błędy w swoich programach.

Oto podsumowanie z samouczka na temat twierdzeń Pythona, które napisałem:

Instrukcja assert Pythona stanowi pomoc w debugowaniu, a nie mechanizm obsługi błędów w czasie wykonywania. Celem stosowania asercji jest umożliwienie programistom szybszego znalezienia prawdopodobnej przyczyny błędu. Błąd asercji nigdy nie powinien być zgłaszany, chyba że w twoim programie jest błąd.

Inni już dali ci linki do dokumentacji.

Możesz wypróbować następujące opcje w interaktywnej powłoce:

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

Pierwsze zdanie nic nie robi, a drugie podnosi wyjątek. Jest to pierwsza wskazówka: aserty są przydatne do sprawdzania warunków, które powinny być prawdziwe w danej pozycji kodu (zwykle na początku (warunki wstępne) i na końcu funkcji (warunki dodatkowe)).

Aserty są w rzeczywistości ściśle powiązane z programowaniem na podstawie umowy, co jest bardzo przydatną praktyką inżynierską:

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

Z dokumentów:

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

Tutaj możesz przeczytać więcej: http://docs.python.org/release/2.5.2/ref/assert.html

Instrukcja assert ma dwie formy.

Prosta forma assert <expression>, jest odpowiednikiem

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

Rozszerzona forma assert <expression1>, <expression2>, jest równoważna

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

Asercje to systematyczny sposób sprawdzania, czy wewnętrzny stan programu jest zgodny z oczekiwaniami programisty, w celu wykrycia błędów. Zobacz przykład poniżej.

>>> 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!
>>> 

Oto prosty przykład, zapisz to w pliku (powiedzmy b.py)

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


chkassert('a')

a wynik kiedy $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

jeśli instrukcja po potwierdzeniu jest prawdziwa, program kontynuuje działanie, ale jeśli instrukcja po potwierdzeniu jest fałszywa, wówczas program podaje błąd. Proste.

na przykład:

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

assertOświadczenie istnieje w prawie każdym języku programowania. Pomaga wykryć problemy na wczesnym etapie programu, gdzie przyczyna jest wyraźna, a nie później jako efekt uboczny innej operacji. Zawsze oczekują Truewarunku.

Kiedy robisz coś takiego:

assert condition

Mówisz programowi, aby przetestował ten warunek i natychmiast wywołał błąd, jeśli jest fałszywy.

W Pythonie assertwyrażenie jest równoważne z:

if __debug__:
    if not <expression>: raise AssertionError

Możesz użyć wyrażenia rozszerzonego, aby przekazać opcjonalny komunikat :

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

Wypróbuj w interpreterie języka Python:

>>> 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

Jest kilka ostrzeżeń, które należy zobaczyć przed użyciem ich głównie dla tych, którzy uważają, że przełączają się między instrukcjami asserti if. Celem jest użycie, assertgdy program weryfikuje warunek i zwraca wartość, która powinna natychmiast zatrzymać program, zamiast wybierać alternatywny sposób obejścia błędu:

1. Nawiasy

Jak zapewne zauważyłeś, assertinstrukcja wykorzystuje dwa warunki. Dlatego nie używaj nawiasów, aby je globalizować jako oczywiste porady. Jeśli to zrobisz:

assert (condition, message)

Przykład:

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

Będziesz działał assertz (condition, message)parametrem, który reprezentuje krotkę jako pierwszy parametr, a dzieje się tak, ponieważ niepuste krotki w Pythonie są zawszeTrue . Możesz jednak zrobić to oddzielnie bez problemu:

assert (condition), "message"

Przykład:

>>> 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. Cel debugowania

Jeśli zastanawiasz się, kiedy użyć assertinstrukcji. Weź przykład wykorzystany w prawdziwym życiu:

* Gdy twój program ma tendencję do kontrolowania każdego parametru wprowadzonego przez użytkownika lub cokolwiek innego:

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())

* Kolejny przypadek dotyczy matematyki, gdy 0 lub wartość dodatnia jako współczynnik lub stała na pewnym równaniu:

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

* lub nawet prosty przykład implementacji boolean:

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

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

3. Przetwarzanie lub walidacja danych

Niezwykle ważne jest, aby nie polegać na assertinstrukcji do przetwarzania danych lub sprawdzania poprawności danych, ponieważ tę instrukcję można wyłączyć przy inicjalizacji języka Python za pomocą -Olub -OOflagi - odpowiednio wartości 1, 2 i 0 (domyślnie) - lub PYTHONOPTIMIZEzmiennej środowiskowej .

Wartość 1:

* twierdzenia są wyłączone;

* pliki kodu bajtowego są generowane przy użyciu .pyorozszerzenia zamiast .pyc;

* sys.flags.optimizejest ustawiony na 1 ( True);

* i __debug__jest ustawiony na False;

Wartość 2: wyłącza jeszcze jedną rzecz

* dokumenty są wyłączone;

Dlatego używanie assertinstrukcji do sprawdzania poprawności rodzaju oczekiwanych danych jest niezwykle niebezpieczne, co sugeruje nawet pewne problemy z bezpieczeństwem. Następnie, jeśli potrzebujesz zweryfikować jakieś pozwolenie, polecam raise AuthErrorzamiast tego. Jako warunek wstępny, programista assertjest powszechnie używany przez programistów w bibliotekach lub modułach, które nie wymagają bezpośredniej interakcji użytkownika.

Jak streszczono zwięźle na Wiki Wiki :

Asercja jest wyrażeniem logicznym w określonym punkcie programu, co będzie prawdziwe, chyba że w programie wystąpi błąd.

Za pomocą assertinstrukcji można udokumentować zrozumienie kodu w określonym punkcie programu. Na przykład można udokumentować założenia lub gwarancje dotyczące danych wejściowych (warunki wstępne), stanu programu (niezmienniki) lub wyników (warunki dodatkowe).

Jeśli twoje twierdzenie kiedykolwiek się nie powiedzie, jest to ostrzeżenie dla ciebie (lub twojego następcy), że twoje zrozumienie programu było błędne, kiedy go napisałeś, i że prawdopodobnie zawiera błąd.

Aby uzyskać więcej informacji, John Regehr ma wspaniały wpis na blogu na temat korzystania z asercji , który dotyczy również assertinstrukcji Python .

Jeśli kiedykolwiek chcesz dokładnie wiedzieć, co funkcja zarezerwowana robi w Pythonie, wpisz help(enter_keyword)

Upewnij się, że jeśli wprowadzasz zarezerwowane słowo kluczowe, które wpisujesz jako ciąg.

Aser Python jest w zasadzie pomocą do debugowania, która testuje warunki wewnętrznej kontroli twojego kodu. Assert sprawia, że ​​debugowanie jest naprawdę łatwe, gdy kod wpada w niemożliwe przypadki brzegowe. Zapewnij sprawdź te niemożliwe przypadki.

Załóżmy, że istnieje funkcja obliczania ceny produktu po rabacie:

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

w tym przypadku cena ze zniżką nigdy nie może być mniejsza niż 0 i większa od rzeczywistej ceny. Tak więc, w przypadku naruszenia powyższego warunku, assert wywołuje błąd asercji, który pomaga deweloperowi zidentyfikować, że stało się coś niemożliwego.

Mam nadzieję, że to pomoże :)

Moje krótkie wyjaśnienie to:

• assertpodnosi, AssertionErrorjeśli wyrażenie jest fałszywe, w przeciwnym razie po prostu kontynuuje kod, a jeśli jest przecinek, czymkolwiek będzie AssertionError: whatever after comma, a kod jest jak:raise AssertionError(whatever after comma)

Powiązany samouczek na ten temat:

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

W programie Pycharm, jeśli użyjesz assertgo isinstancedo zadeklarowania typu obiektu, pozwoli ci on uzyskać dostęp do metod i atrybutów obiektu nadrzędnego podczas kodowania, automatycznie się uzupełni.

Załóżmy na przykład, że self.object1.object2jest MyClassobiektem.

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

Jak napisano w innych odpowiedziach, assertinstrukcje służą do sprawdzania stanu programu w danym punkcie.

Nie powtórzę tego, co zostało powiedziane na temat powiązanej wiadomości, nawiasów lub -Oopcji i __debug__stałej. Sprawdź także dokument, aby uzyskać informacje z pierwszej ręki. Skoncentruję się na twoim pytaniu: do czego służy assert? Mówiąc dokładniej, kiedy (a kiedy nie) należy użyć assert?

Te assertstwierdzenia są przydatne do debugowania programu, ale zniechęcony do sprawdzenia danych wprowadzonych przez użytkownika. Używam następującej zasady: zachowaj twierdzenia, aby wykryć, że taka sytuacja nie powinna się zdarzyć . Wprowadzane przez użytkownika dane mogą być niepoprawne, np. Hasło jest za krótkie, ale nie jest to przypadek, który nie powinien się zdarzyć . Jeśli średnica koła nie jest dwa razy większa niż jego promień, oznacza to, że nie powinno się to zdarzyć .

Moim zdaniem najciekawsze użycie assertinspirowane jest programowaniem na podstawie umowy, jak opisano przez B. Meyera w [Object-Oriented Software Construction] ( https://www.eiffel.org/doc/eiffel/Object-Oriented_Software_Construction% 2C_2nd_Edition ) i zaimplementowane w [języku programowania Eiffel] ( https://en.wikipedia.org/wiki/Eiffel_(programming_language) ). Nie można w pełni emulować programowania na podstawie umowy za pomocą assertinstrukcji, ale warto zachować intencję.

Oto przykład. Wyobraź sobie, że musisz napisać headfunkcję (jak [ headfunkcja w Haskell] ( http://www.zvon.org/other/haskell/Outputprelude/head_f.html )). Podana specyfikacja to: „jeśli lista nie jest pusta, zwróć pierwszą pozycję na liście”. Spójrz na następujące implementacje:

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

I

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

_{(Tak, można to zapisać jako return xs[0] if xs else None, ale nie o to chodzi)} .

Jeśli lista nie jest pusta, obie funkcje mają ten sam wynik i ten wynik jest poprawny:

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

Dlatego obie implementacje są (mam nadzieję) poprawne. Różnią się, gdy próbujesz zabrać nagłówek pustej listy:

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

Ale:

>>> head2([]) is None
True

Ponownie obie implementacje są poprawne, ponieważ nikt nie powinien przekazywać pustej listy do tych funkcji (jesteśmy poza specyfikacją ). To niepoprawne połączenie, ale jeśli wykonasz takie połączenie, wszystko może się zdarzyć. Jedna funkcja wywołuje wyjątek, druga zwraca specjalną wartość. Najważniejsze jest: nie możemy polegać na tym zachowaniu . Jeśli xsjest pusty, to zadziała:

print(head2(xs))

Spowoduje to jednak awarię programu:

print(head1(xs))

Aby uniknąć niespodzianek, chciałbym wiedzieć, kiedy przekazuję nieoczekiwany argument funkcji. Innymi słowy: chciałbym wiedzieć, kiedy obserwowalne zachowanie nie jest wiarygodne, ponieważ zależy to od implementacji, a nie od specyfikacji. Oczywiście mogę przeczytać specyfikację, ale programiści nie zawsze dokładnie czytają dokumenty.

Wyobraź sobie, że mam sposób, aby wstawić specyfikację do kodu, aby uzyskać następujący efekt: gdy naruszę specyfikację, np. Przekazując pustą listę head, otrzymam ostrzeżenie. Byłoby to bardzo pomocne w napisaniu poprawnego (tj. Zgodnego ze specyfikacją) programu. I tam assert wkracza na scenę:

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

I

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

Teraz mamy:

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

I:

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

Zauważ, że head1wyrzuca an AssertionError, a nie an IndexError. Jest to ważne, ponieważ an AssertionErrornie jest żadnym błędem środowiska wykonawczego: sygnalizuje naruszenie specyfikacji. Chciałem ostrzeżenia, ale pojawia się błąd. Na szczęście mogę wyłączyć kontrolę (korzystając z -Oopcji), ale na własne ryzyko. Zrobię to, awaria jest naprawdę droga i mam nadzieję na najlepsze. Wyobraź sobie, że mój program jest osadzony w statku kosmicznym, który podróżuje przez czarną dziurę. Wyłączę asercje i mam nadzieję, że program jest wystarczająco solidny, aby nie powodować awarii tak długo, jak to możliwe.

Ten przykład dotyczył tylko warunków wstępnych, assertponieważ można użyć do sprawdzenia warunków dodatkowych (wartość zwracana i / lub stan) i niezmienników (stan klasy). Pamiętaj, że sprawdzanie warunków dodatkowych i niezmienników za pomocą assertmoże być kłopotliwe:

• w przypadku warunków dodatkowych należy przypisać wartość zwracaną do zmiennej, a może przechowywać stan początkowy obiektu, jeśli ma się do czynienia z metodą;
• w przypadku niezmienników należy sprawdzić stan przed i po wywołaniu metody.

Nie będziesz mieć czegoś tak wyrafinowanego jak Eiffel, ale możesz jednak poprawić ogólną jakość programu.

Podsumowując, assertstwierdzenie to wygodny sposób na wykrycie takiej sytuacji, która nie powinna się zdarzyć . Naruszenie specyfikacji (np. Przekazanie pustej listy head) jest pierwszą klasą, nie powinno się zdarzyć . Dlatego chociaż assertoświadczenie może być użyte do wykrycia każdej nieoczekiwanej sytuacji, jest to uprzywilejowany sposób zapewnienia spełnienia specyfikacji. Po wstawieniu assertinstrukcji do kodu reprezentujących specyfikację możemy mieć nadzieję, że poprawiłeś jakość programu, ponieważ zostaną zgłoszone niepoprawne argumenty, niepoprawne wartości zwracane, niepoprawne stany klasy ...

format: assert Expression [, argumenty] Gdy aser napotka instrukcję, Python ocenia wyrażenie. Jeśli instrukcja nie jest prawdziwa, zgłaszany jest wyjątek (assertionError). Jeśli asercja się nie powiedzie, Python użyje ArgumentExpression jako argumentu dla AssertionError. Wyjątki AssertionError mogą być wychwytywane i obsługiwane jak każdy inny wyjątek za pomocą instrukcji try-wyjątek, ale jeśli nie zostaną obsłużone, zakończą program i wygenerują śledzenie. Przykład:

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)    

Wykonanie powyższego kodu powoduje następujący wynik:

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

Może być użyty, aby zapewnić przekazanie parametrów w wywołaniu funkcji.

>>>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
>>> 

Zasadniczo znaczenie słowa kluczowego assert polega na tym, że jeśli warunek nie jest spełniony, to przez asertywność lub w przeciwnym razie kontynuuje na przykład w pythonie.

kod-1

a=5

b=6

assert a==b

WYNIK:

assert a==b

AssertionError

kod-2

a=5

b=5

assert a==b

WYNIK:

Process finished with exit code 0