පයිතන්හි “තහවුරු කිරීම” භාවිතා කරන්නේ කුමක් ද?

මම යම් ප්‍රභව කේතයක් කියවා ඇති අතර ස්ථාන කිහිපයක භාවිතය දැක ඇත්තෙමි assert.

එය හරියටම අදහස් කරන්නේ කුමක්ද? එහි භාවිතය කුමක්ද?

මෙම assertප්රකාශය වැඩසටහන් සෑම භාෂා පවතී. එය ඔබගේ වැඩසටහනේ මුල් අවදියේදී ගැටළු හඳුනා ගැනීමට උපකාරී වේ, හේතුව පැහැදිලි වන අතර පසුව වෙනත් මෙහෙයුමක අතුරු as ලයක් ලෙස නොව.

ඔබ කරන විට ...

assert condition

... ඔබ වැඩසටහනට පවසන්නේ එම තත්වය පරීක්ෂා කරන ලෙසයි.

පයිතන්හි එය දළ වශයෙන් මෙයට සමාන ය:

if not condition:
    raise AssertionError()

පයිතන් කවචයෙන් එය උත්සාහ කරන්න:

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

ප්‍රකාශයන්ට විකල්ප පණිවිඩයක් ඇතුළත් කළ හැකි අතර, පරිවර්තකය ක්‍රියාත්මක කිරීමේදී ඔබට ඒවා අක්‍රිය කළ හැකිය.

ප්‍රකාශය අසමත් වුවහොත් පණිවිඩයක් මුද්‍රණය කිරීම සඳහා:

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

එපා නොවන ඇමතුම් සඳහා වරහන භාවිතා assertඋත්සවයකට වගේ. එය ප්‍රකාශයකි. ඔබ එසේ කළහොත් ඔබ පළමු පරාමිතිය ලෙස ටුපල් සමඟ assert(condition, message)ධාවනය කරනු assertඇත (condition, message).

ක්රියාත්මක වන විට, ඔවුන් අක්රිය කිරීමේ ලෙස pythonඑහිදී දැන කෙලෙසුන් කෙරෙන් ආකාරය, __debug__ඇත False, අණසක පැතිරීමට ප්රකාශ නොසලකා හරිනු ලැබේ. -Oධජය පසුකර යන්න :

python -O script.py

අදාළ ලියකියවිලි සඳහා මෙහි බලන්න .

වරහන් සඳහා අවධානයෙන් සිටින්න. ලෙස, ඉහත පෙන්වා දී ඇති python, 3, assertප්රකාශයක් තවමත් ඒ සමඟ සාම්යයක්, print(..)එක් කිරීම සඳහා එම extrapolate හැක assert(..)හෝ raise(..)එහෙත් ඔබ කළ යුතු නැහැ.

මෙය වැදගත් වන්නේ:

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

මෙන් නොව ක්‍රියා නොකරනු ඇත

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

පළමු එක ක්‍රියාත්මක නොවීමට හේතුව bool( (False, "Houston we've got a problem") )ඇගයීමයි True.

ප්රකාශයේ දී assert(False), මේවා අවට අතිරික්ත වරහන් පමණක් Falseවන අතර ඒවායේ අන්තර්ගතය තක්සේරු කරයි. නමුත් assert(False,)වරහන් සමඟ දැන් ටුපල් එකක් වන අතර හිස් නොවන ටුපල් Trueඑකක් බූලියන් සන්දර්භයක් තුළ ඇගයීමට ලක් කරයි .

වෙනත් පිළිතුරු සටහන් කර ඇති පරිදි, assertදී ඇති කොන්දේසියක් සත්‍ය නොවේ නම් ව්‍යතිරේකයක් විසි කිරීමට සමාන වේ. වැදගත් වෙනසක් නම්, ඔබ ඔබේ කේතය ප්‍රශස්තිකරණ විකල්පය සමඟ සම්පාදනය කරන්නේ නම් ප්‍රකාශ ප්‍රකාශ නොසලකා හරිනු -Oඇත. මෙම ප්රලේඛනය පවසයි assert expressionවඩා හොඳ සමාන ලෙස විස්තර කළ හැකි ය

if __debug__:
   if not expression: raise AssertionError

ඔබේ කේතය තරයේ පරීක්‍ෂා කිරීමට අවශ්‍ය නම් මෙය ප්‍රයෝජනවත් විය හැකි අතර, ඔබේ ප්‍රකාශ කිරීමේ සිද්ධීන් කිසිවක් අසමත් වීම ගැන ඔබ සතුටු වන විට ප්‍රශස්තිකරණය කළ අනුවාදයක් නිකුත් කරන්න - ප්‍රශස්තිකරණය ක්‍රියාත්මක වන විට __debug__විචල්‍යය අසත්‍ය බවට පත්වන අතර කොන්දේසි ඇගයීම නවත්වනු ඇත. ඔබ ප්‍රකාශයන් මත විශ්වාසය තබා ඒවා අතුරුදහන් වී ඇති බව නොදැන සිටියහොත් මෙම අංගයටද ඔබව හසු කර ගත හැකිය.

පයිතන්හි ප්‍රකාශයක පරමාර්ථය වන්නේ වැඩසටහනක සොයාගත නොහැකි දෝෂ පිළිබඳව සංවර්ධකයින් දැනුවත් කිරීමයි.

පරිශීලකයාට නිවැරදි කිරීමේ ක්‍රියාමාර්ගයක් ගත හැකි (හෝ නැවත උත්සාහ කරන්න) “ගොනුව හමු නොවීය” වැනි අපේක්ෂිත දෝෂ තත්වයන් සං signal ා කිරීමට ප්‍රකාශයන් අදහස් නොකෙරේ.

එය බැලීමට තවත් ක්‍රමයක් නම්, ඔබේ කේතයේ අභ්‍යන්තර ස්වයං පරීක්ෂාවන් බව ප්‍රකාශ කිරීමයි. ඔබේ කේතයේ සමහර කොන්දේසි කළ නොහැකි යැයි ප්‍රකාශ කිරීමෙන් ඒවා ක්‍රියාත්මක වේ. මෙම කොන්දේසි නොපවතින්නේ නම් එයින් අදහස් වන්නේ වැඩසටහනේ දෝෂයක් ඇති බවයි.

ඔබේ වැඩසටහන දෝෂ රහිත නම්, මෙම තත්වයන් කිසි විටෙකත් සිදු නොවේ. එහෙත් ඉන් එකක් නම් කරන්නේ මෙම වැඩසටහන සිදුවේ "නොහැකි" තත්ත්වයේ අවුලුවන ලද හරියටම කියනවා ඔබට, ප්රකාශයකින් දෝෂය සමඟ ඇති වනවා. මෙය ඔබගේ වැඩසටහන් වල දෝෂ සොයා ගැනීමට සහ නිවැරදි කිරීමට පහසු කරයි.

මෙන්න මම ලියූ පයිතන්ගේ ප්‍රකාශයන් පිළිබඳ නිබන්ධනයක සාරාංශයක් :

පයිතන්ගේ ප්‍රකාශ ප්‍රකාශය නිදොස් කිරීමේ ආධාරකයක් මිස ධාවන කාල දෝෂ හැසිරවීමේ යාන්ත්‍රණයක් නොවේ. ප්‍රකාශයන් භාවිතා කිරීමේ පරමාර්ථය වන්නේ දෝෂයකට මුල් හේතුව සොයා ගැනීමට සංවර්ධකයින්ට ඉඩ දීමයි. ඔබේ වැඩසටහනේ දෝෂයක් නොමැති නම් කිසි විටෙකත් ප්‍රකාශ කිරීමේ දෝෂයක් මතු නොවිය යුතුය.

අනෙක් අය දැනටමත් ඔබට ලේඛනවලට සබැඳි ලබා දී ඇත.

අන්තර්ක්‍රියාකාරී කවචයකින් ඔබට පහත දෑ උත්සාහ කළ හැකිය:

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

පළමු ප්‍රකාශය කිසිවක් නොකරන අතර දෙවැන්න ව්‍යතිරේකයක් මතු කරයි. මෙය පළමු ඉඟියයි: ඔබේ කේතයේ දී ඇති ස්ථානයක (සාමාන්‍යයෙන්, ආරම්භය (පූර්ව කොන්දේසි) සහ ශ්‍රිතයක අවසානය (පසු කොන්දේසි)) සත්‍ය විය යුතු කොන්දේසි පරීක්ෂා කිරීමට ප්‍රකාශයන් ප්‍රයෝජනවත් වේ.

කොන්ත්‍රාත්තු මගින් වැඩසටහන්කරණය සමඟ සැබවින්ම බැඳී ඇති අතර එය ඉතා ප්‍රයෝජනවත් ඉංජිනේරු භාවිතයකි:

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

ලියකියවිලි වලින්:

ප්‍රකාශය යනු නිදොස් කිරීමේ ප්‍රකාශයන් වැඩසටහනකට ඇතුළත් කිරීමට පහසු ක්‍රමයකි

ඔබට මෙහි වැඩිදුර කියවිය හැකිය: http://docs.python.org/release/2.5.2/ref/assert.html

ප්‍රකාශ ප්‍රකාශයට ආකාර දෙකක් ඇත.

සරල ස්වරූපය, assert <expression>සමාන වේ

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

විස්තාරිත ආකෘතිය, assert <expression1>, <expression2>සමාන වේ

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

දෝෂයන් හසු කර ගැනීමේ අරමුන ඇතිව, ක්‍රමලේඛකයා අපේක්ෂා කළ ආකාරයටම වැඩසටහනක අභ්‍යන්තර තත්වය තිබේදැයි පරීක්ෂා කිරීම ක්‍රමානුකූල ක්‍රමයකි. පහත උදාහරණය බලන්න.

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

මෙන්න සරල උදාහරණයක්, මෙය ගොනුවේ සුරකින්න (b.py යැයි කියමු)

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


chkassert('a')

සහ ප්‍රති result ලය කවදාද $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

තහවුරු කිරීමෙන් පසු ප්‍රකාශය සත්‍ය නම් වැඩසටහන දිගටම පවතී, නමුත් ප්‍රකාශ කිරීමෙන් පසු ප්‍රකාශය අසත්‍ය නම් වැඩසටහන දෝෂයක් ලබා දෙයි. ඒ තරම් සරළයි.

උදා:

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

මෙම assertප්රකාශය වැඩසටහන් සෑම භාෂා පවතී. එය ඔබගේ වැඩසටහනේ මුල් අවදියේදී ගැටළු හඳුනා ගැනීමට උපකාරී වේ, හේතුව පැහැදිලි වන අතර පසුව වෙනත් මෙහෙයුමක අතුරු as ලයක් ලෙස නොව. ඔවුන් සෑම විටම Trueකොන්දේසියක් අපේක්ෂා කරයි .

ඔබ එවැනි දෙයක් කරන විට:

assert condition

ඔබ වැඩසටහනට පවසන්නේ එම තත්වය පරීක්ෂා කර එය වැරදියි නම් වහාම දෝෂයක් ඇති කරන ලෙසයි.

පයිතන්හි assertප්‍රකාශනය සමාන වේ:

if __debug__:
    if not <expression>: raise AssertionError

විකල්ප පණිවිඩයක් යැවීමට ඔබට දීර් expression ප්‍රකාශනය භාවිතා කළ හැකිය :

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

පයිතන් පරිවර්තකය තුළ එය උත්සාහ කරන්න:

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

ප්‍රධාන වශයෙන් assertසහ ifප්‍රකාශ අතර ටොගල් කිරීමට සිතන අය සඳහා ඒවා භාවිතා කිරීමට පෙර දැකිය යුතු අනතුරු ඇඟවීම් කිහිපයක් තිබේ . භාවිතා කිරීමේ පරමාර්ථය assertවන්නේ වැඩසටහන විසින් කොන්දේසියක් සත්‍යාපනය කර දෝෂය මඟහරවා ගැනීම සඳහා විකල්ප ක්‍රමයක් ගැනීම වෙනුවට වැඩසටහන වහාම නැවැත්විය යුතු අගයක් ලබා දීමයි.

1. වරහන්

ඔබ දැක ඇති පරිදි, assertප්‍රකාශය කොන්දේසි දෙකක් භාවිතා කරයි. ඒ නිසා, නෑ නෑ පැහැදිලි උපදෙස් සඳහා එක් ලෙස englobe කිරීමට වරහන් භාවිතා කරන්න. ඔබ එවැනි දෙයක් කරන්නේ නම්:

assert (condition, message)

උදාහරණයක්:

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

ඔබ ධාවනය කරනු ඇත assertසමඟ (condition, message)පළමු පරාමිතිය ලෙස tuple නියෝජනය කරන අතර, මෙය සිදු Python දී, හිස්-නොවන tuple වේ හේතුව වන සෑම විටමTrue . කෙසේ වෙතත්, ඔබට ගැටලුවකින් තොරව වෙන වෙනම කළ හැකිය:

assert (condition), "message"

උදාහරණයක්:

>>> 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. නිදොස් කිරීමේ අරමුණ

assertප්‍රකාශය භාවිතා කරන විට ඔබ කල්පනා කරන්නේ නම් . සැබෑ ජීවිතයේ භාවිතා වන උදාහරණයක් ගන්න:

* ඔබේ වැඩසටහන මඟින් පරිශීලකයා ඇතුළු කළ සෑම පරාමිතියක්ම පාලනය කිරීමට නැඹුරු වූ විට හෝ වෙනත් ඕනෑම දෙයක්:

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

* තවත් සිද්ධියක් ගණිතය මත 0 හෝ ධනාත්මක නොවන විට සංගුණකයක් හෝ නියතයක් ලෙස නිශ්චිත සමීකරණයක් මත වේ:

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

* හෝ බූලියන් ක්‍රියාත්මක කිරීම පිළිබඳ සරල උදාහරණයක්:

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

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

3. දත්ත සැකසීම හෝ දත්ත වලංගු කිරීම

ඉතා වැදගත් මත විශ්වාසය තැබිය නො වේ assertමෙම ප්රකාශය සමග Python ඇරඹෙන දා පත් කළ හැකිය නිසා දත්ත සකසන හෝ දත්ත වලංගුකරණය ක්රියාත්මක කිරීමට ප්රකාශයක් -Oහෝ -OOඅර්ථය අගය 1, 2, 0 (පෙරනිමි ලෙස), පිළිවෙළින් - - හෝ ධජය PYTHONOPTIMIZEපරිසර විචල්ය .

අගය 1:

* ප්‍රකාශ අක්‍රීය කර ඇත;

* බයිට් කේත ගොනු ජනනය කරනුයේ .pyoඒ වෙනුවට දිගුව භාවිතා කරමිනි .pyc;

* sys.flags.optimize1 ( True) ලෙස සකසා ඇත ;

* සහ, __debug__ලෙස සකසා ඇත False;

අගය 2: තවත් එක් දෙයක් අක්‍රීය කරයි

* docstrings අක්‍රීය කර ඇත;

එබැවින්, assertඅපේක්ෂිත දත්ත වර්ගයක් වලංගු කිරීම සඳහා ප්‍රකාශය භාවිතා කිරීම අතිශයින්ම භයානක වන අතර එය සමහර ආරක්ෂක ගැටළු වලට පවා ඇඟවුම් කරයි. ඔබට යම් අවසරයක් වලංගු කිරීමට අවශ්‍ය නම් raise AuthErrorඒ වෙනුවට මම ඔබට නිර්දේශ කරමි . පූර්ව කොන්දේසි සහිත effective ලදායී ලෙස, assertපරිශීලකයෙකු සෘජුවම අන්තර්ක්‍රියා නොකරන පුස්තකාල හෝ මොඩියුලවල ක්‍රමලේඛකයින් විසින් බහුලව භාවිතා කරයි.

සී 2 විකියෙහි සංක්ෂිප්තව සාරාංශගත කර ඇති පරිදි :

ප්‍රකාශයක් යනු වැඩසටහනක නිශ්චිත අවස්ථාවක දී බූලියන් ප්‍රකාශනයක් වන අතර එය වැඩසටහනේ දෝෂයක් නොමැති නම් සත්‍ය වේ.

assertවිශේෂිත වැඩසටහන් ස්ථානයක කේතය පිළිබඳ ඔබේ අවබෝධය ලේඛනගත කිරීමට ඔබට ප්‍රකාශයක් භාවිතා කළ හැකිය . උදාහරණයක් ලෙස, ඔබට යෙදවුම් (පූර්ව කොන්දේසි), වැඩසටහන් තත්වය (වෙනස්වීම්) හෝ ප්‍රතිදානයන් (පසු කොන්දේසි) පිළිබඳ උපකල්පන හෝ සහතික කිරීම් ලේඛනගත කළ හැකිය.

ඔබේ ප්‍රකාශය කවදා හෝ අසාර්ථක වුවහොත්, මෙය ඔබ (හෝ ඔබේ අනුප්‍රාප්තිකයා) සඳහා වූ අනතුරු ඇඟවීමකි, ඔබ එය ලියන විට වැඩසටහන පිළිබඳ ඔබේ අවබෝධය වැරදියි, සහ එහි දෝෂයක් ඇති බව.

වැඩි විස්තර සඳහා, ජෝන් Regehr මත අපූරු බ්ලොග් ඇත කථනයන් භාවිතය සඳහා python අදාළ වන assertමෙන්ම ප්රකාශයක්.

වෙන් කර ඇති ශ්‍රිතයක් පයිතන් තුළ කරන්නේ කුමක්දැයි ඔබට දැන ගැනීමට අවශ්‍ය නම්, ටයිප් කරන්න help(enter_keyword)

ඔබ වෙන් කර ඇති යතුරු පදයක් නූලක් ලෙස ඇතුළත් කරන්නේ දැයි තහවුරු කරගන්න.

Python මීට උදාහරණ අණසක පැතිරීමට මූලික වශයෙන් ඔබගේ කේතය අභ්යන්තර ස්වයං-චෙක් සඳහා දෝෂහරණ ආධාර වන ටෙස්ට් තත්ත්වය වේ. ඔබේ කේතය කළ නොහැකි අද්දරට වැටෙන විට තහවුරු කිරීම නිදොස් කිරීම සැබවින්ම පහසු කරයි. කළ නොහැකි අවස්ථා පරීක්ෂා කරන්න.

වට්ටම් ලැබීමෙන් පසු අයිතමයේ මිල ගණනය කිරීමේ කාර්යයක් ඇති බව කියමු:

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

මෙහි, වට්ටම්_ප්‍රයිස් කිසි විටෙකත් 0 ට වඩා අඩු විය නොහැකි අතර සැබෑ මිලට වඩා වැඩි විය හැකිය. එබැවින්, ඉහත කොන්දේසිය උල්ලං is නය වී ඇත්නම්, ප්‍රකාශය මඟින් දෝෂයක් මතු කරයි, එය කළ නොහැකි දෙයක් සිදුවී ඇති බව හඳුනා ගැනීමට සංවර්ධකයාට උපකාරී වේ.

එය උපකාරී වේ යැයි සිතමි :)

මගේ කෙටි පැහැදිලි කිරීම නම්:

• assertAssertionErrorප්‍රකාශනය අසත්‍ය නම් මතු කරයි, එසේ නොමැතිනම් කේතය දිගටම කරගෙන යන්න, කොමාවක් තිබේ නම් එය කුමක් වේ ද AssertionError: whatever after comma, කේත කිරීම වැනි ය:raise AssertionError(whatever after comma)

මේ පිළිබඳ අදාළ නිබන්ධනයක්:

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

Pycharm දී, ඔබ භාවිතා කරන්නේ නම් assertසමග isinstanceවස්තුවක් ගණය ලෙස ප්රකාශ කිරීම සඳහා, එය ඔබ මව් වස්තුව ක්රම හා ගුණාංග ප්රවේශ ඔබ කේතනය කරන අතර, එය ස්වයංක්රීය සම්පූර්ණ ස්වයංක්රීයව විශාල ඉඩ ඇත.

උදාහරණයක් ලෙස, එහෙනම් අපි කිව්වොත් self.object1.object2කියන්නේ MyClassවස්තුව.

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

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

ආශ්‍රිත පණිවුඩය, වරහන් හෝ -Oවිකල්පය සහ __debug__නියතය ගැන පැවසූ දේ මම නැවත නොකරමි . පළමු තොරතුරු සඳහා ලේඛනයද පරීක්ෂා කරන්න . මම ඔබේ ප්‍රශ්නය කෙරෙහි අවධානය යොමු කරමි: එයින් ඇති ප්‍රයෝජනය assertකුමක්ද? වඩාත් නිවැරදිව, යමෙකු භාවිතා කළ යුත්තේ කවදාද (කවදාද) assert?

මෙම assertප්රකාශ වැඩසටහනක් එකතුකරන්න ප්රයෝජනවත් වේ, නමුත් පරිශීලක ආදාන පරීක්ෂා කිරීමට ද සිතමි. මම පහත දැක්වෙන නියමය භාවිතා කරමි: මෙය සිදු නොවිය යුතු තත්වයක් හඳුනා ගැනීමට ප්‍රකාශයන් තබා ගන්න . පරිශීලක ආදානය වැරදියි, උදා: මුරපදය ඉතා කෙටි නමුත් මෙය මෙය සිදු නොවිය යුතුය . රවුමක විෂ්කම්භය එහි අරය මෙන් දෙගුණයක් විශාල නොවේ නම්, ඔබ සිටින්නේ මෙය සිදු නොවිය යුතුය .

වඩාත් රසවත්, මගේ සිතේ, භාවිතය assertවිසින් දේවානුභාවයෙන් දුන් කොන්ත්රාත්තුව වැඩසටහන් [වස්තූන්-පිණිසයි මෘදුකාංග ඉදිකිරීම්] දී බී මේයර් එකිනෙකාගෙන් විසින් විස්තර කර ඇති පරිදි ( https://www.eiffel.org/doc/eiffel/Object-Oriented_Software_Construction% 2C_2nd_Edition ) සහ [අයිෆල් ක්‍රමලේඛන භාෂාවෙන්] ( https://en.wikipedia.org/wiki/Eiffel_(programming_language ) ක්‍රියාත්මක කර ඇත. assertප්‍රකාශය භාවිතා කරමින් කොන්ත්‍රාත්තුවක් මඟින් ඔබට ක්‍රමලේඛනය සම්පූර්ණයෙන්ම අනුකරණය කළ නොහැක , නමුත් අභිප්‍රාය තබා ගැනීම සිත්ගන්නා කරුණකි.

මෙන්න උදාහරණයක්. ඔබ headශ්‍රිතයක් ලිවිය යුතු යැයි සිතන්න ([ headහස්කල් හි ශ්‍රිතය] ( http://www.zvon.org/other/haskell/Outputprelude/head_f.html වැනි ). ඔබට ලබා දී ඇති පිරිවිතර: "ලැයිස්තුව හිස් නොවේ නම්, ලැයිස්තුවක පළමු අයිතමය ආපසු එවන්න". පහත සඳහන් ක්‍රියාත්මක කිරීම් දෙස බලන්න:

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

සහ

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

_{(ඔව්, මෙය මෙසේ ලිවිය හැකිය return xs[0] if xs else None, නමුත් එය එසේ නොවේ)} .

ලැයිස්තුව හිස් නොවේ නම්, කාර්යයන් දෙකම එකම ප්‍රති result ලයක් ඇති අතර මෙම ප්‍රති result ලය නිවැරදි ය:

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

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

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

ඒත්:

>>> head2([]) is None
True

නැවතත්, ක්‍රියාත්මක කිරීම් දෙකම නිවැරදි ය, මන්ද කිසිවෙකු මෙම කාර්යයන් සඳහා හිස් ලැයිස්තුවක් නොයැවිය යුතු ය (අප පිරිවිතරයෙන් බැහැර ය ). එය වැරදි ඇමතුමකි, නමුත් ඔබ එවැනි ඇමතුමක් කළහොත් ඕනෑම දෙයක් සිදුවිය හැකිය. එක් ශ්‍රිතයක් ව්‍යතිරේකයක් මතු කරයි, අනෙක විශේෂ අගයක් ලබා දෙයි. වැදගත්ම දෙය නම්: අපට මෙම හැසිරීම මත විශ්වාසය තැබිය නොහැක . xsහිස් නම් , මෙය ක්‍රියාත්මක වනු ඇත:

print(head2(xs))

නමුත් මෙය වැඩසටහන බිඳ වැටෙනු ඇත:

print(head1(xs))

සමහර විස්මයන් වළක්වා ගැනීම සඳහා, මම කිසියම් අනපේක්ෂිත තර්කයක් ශ්‍රිතයකට යොමු කරන විට දැන ගැනීමට කැමතියි. වෙනත් වචන වලින් කිවහොත්: නිරීක්ෂණය කළ හැකි හැසිරීම විශ්වාසදායක නොවන විට මම දැන ගැනීමට කැමතියි, මන්ද එය ක්‍රියාත්මක කිරීම මත රඳා පවතී, පිරිවිතර මත නොවේ. ඇත්ත වශයෙන්ම, මට පිරිවිතර කියවිය හැකිය, නමුත් ක්‍රමලේඛකයින් සෑම විටම ලේඛය හොඳින් කියවන්නේ නැත.

පහත දැක්වෙන ප්‍රති get ල ලබා ගැනීම සඳහා කේතයට පිරිවිතර ඇතුළත් කිරීමට මට ක්‍රමයක් තිබේදැයි සිතා බලන්න: මම පිරිවිතර උල්ලං When නය කරන විට, උදා: හිස් ලැයිස්තුවක් යැවීමෙන් headමට අනතුරු ඇඟවීමක් ලැබේ. නිවැරදි (එනම් පිරිවිතරයන්ට අනුකූල) වැඩසටහනක් ලිවීමට එය විශාල උපකාරයක් වනු ඇත. එහිදී ඒ තියෙන්නේ assert එම ස්ථානයට ඇතුල්:

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

සහ

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

දැන්, අපට ඇත්තේ:

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

සහ:

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

බව සටහන head1ක අවුලට AssertionErrorනැහැ, ක IndexError. එය වැදගත් AssertionErrorවන්නේ කිසියම් ධාවන කාල දෝෂයක් නොවන බැවිනි : එය පිරිවිතර උල්ලං violation නය කිරීමක් සං als ා කරයි. මට අනතුරු ඇඟවීමක් අවශ්‍ය නමුත් මට දෝෂයක් ඇතිවිය. වාසනාවකට මෙන්, මට චෙක්පත අක්‍රීය කළ හැකිය ( -Oවිකල්පය භාවිතා කරමින් ), නමුත් මගේම අවදානමක. කඩාවැටීම සැබවින්ම මිල අධික වන අතර හොඳම දේ ගැන බලාපොරොත්තු වෙමි. මගේ වැඩසටහන කළු කුහරයක් හරහා ගමන් කරන අභ්‍යවකාශ යානයක කාවැදී ඇතැයි සිතන්න. මම ප්‍රකාශයන් අක්‍රීය කර, හැකි තාක් කල් බිඳ වැටීමට නොහැකි තරමට වැඩසටහන ශක්තිමත් යැයි සිතමි.

මෙම උදාහරණය පූර්ව කොන්දේසි ගැන පමණි, ඔබට assertපශ්චාත් කොන්දේසි (ප්‍රතිලාභ අගය සහ / හෝ රාජ්‍යය) සහ ආක්‍රමණ (පන්තියක තත්වය) පරීක්ෂා කිරීමට භාවිතා කළ හැකිය . පසු කොන්දේසි සහ වෙනස්වීම් පරීක්ෂා කිරීම assertකරදරකාරී විය හැකි බව සලකන්න:

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

ඔබට අයිෆල් තරම් නවීන දෙයක් නොමැත, නමුත් ඔබට කෙසේ වෙතත් වැඩසටහනක සමස්ත ගුණාත්මකභාවය වැඩි දියුණු කළ හැකිය.

සාරාංශගත කිරීම සඳහා, මෙම assertප්‍රකාශය මෙය සිදු නොවිය යුතු තත්වයක් හඳුනා ගැනීමට පහසු ක්‍රමයකි . පිරිවිතර උල්ලං lations නය කිරීම් (උදා: හිස් ලැයිස්තුවක් වෙත යැවීම head) පළමු පන්තිය වන අතර මෙය සිදුවිය යුතු නොවේ . එබැවින්, assertකිසියම් අනපේක්ෂිත තත්වයක් හඳුනා ගැනීම සඳහා ප්‍රකාශය භාවිතා කළ හැකි වුවද, පිරිවිතරයන් සපුරා ඇති බව සහතික කිරීම වරප්‍රසාදිත ක්‍රමයකි. assertපිරිවිතරයන් නිරූපණය කිරීම සඳහා ඔබ කේතයට ප්‍රකාශ ඇතුළත් කළ පසු, ඔබ වැඩසටහනේ ගුණාත්මක භාවය වැඩි දියුණු කර ඇතැයි අපට විශ්වාස කළ හැකිය, මන්ද වැරදි තර්ක, වැරදි ප්‍රතිලාභ අගයන්, පන්තියක වැරදි තත්වයන් ..., වාර්තා වනු ඇත.

ආකෘතිය: assert Expression [, තර්ක] ප්‍රකාශයක් ප්‍රකාශ කළ විට, පයිතන් ප්‍රකාශනය ඇගයීමට ලක් කරයි. ප්‍රකාශය සත්‍ය නොවේ නම්, ව්‍යතිරේකයක් මතු වේ (assertionError). ප්‍රකාශය අසමත් වුවහොත්, පයිතන් විසින් තර්කය ලෙස තර්කය ලෙස ArgumentExpression භාවිතා කරයි. උත්සාහය හැර ප්‍රකාශය භාවිතා කරමින් වෙනත් ව්‍යතිරේකයක් මෙන් තහවුරු කිරීම් දෝෂ ව්‍යතිරේකයන් හසු කර ගත හැකි නමුත් ඒවා හසුරුවන්නේ නැත්නම්, ඔවුන් වැඩසටහන අවසන් කර හෝඩුවාවක් නිපදවනු ඇත. උදාහරණයක්:

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)    

ඉහත කේතය ක්‍රියාත්මක කළ විට, එය පහත ප්‍රති result ලය ලබා දෙයි:

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

ශ්‍රිත ඇමතුමෙහි පරාමිතීන් සම්මත වී ඇති බව සහතික කිරීමට භාවිතා කළ හැකිය.

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

මූලික වශයෙන් තහවුරු කිරීමේ මූලපදයේ තේරුම නම් තත්වය සත්‍ය නොවේ නම් එය තහවුරු කිරීමේ දෝෂයක් හරහා වෙනත් ආකාරයකින් එය පයිතන්හි දිගටම පවතින බවයි.

කේතය -1

a=5

b=6

assert a==b

නිමැවුම්:

assert a==b

AssertionError

කේතය -2

a=5

b=5

assert a==b

නිමැවුම්:

Process finished with exit code 0