පයිතන් පරිවර්තකයා ප්‍රභව ගොනුවක් කියවන සෑම විටම එය කරුණු දෙකක් කරයි:
__name__පයිතන් ස්ක්‍රිප්ට් වල අප සැමවිටම දකින චෙක්පත් පිළිබඳ ඔබේ ප්‍රශ්නයට මෙය සම්බන්ධ වන්නේ කෙසේද සහ එය සම්බන්ධ වන්නේ කෙසේදැයි බලමු .
කේත නියැදිය
ආනයන සහ ස්ක්‍රිප්ට් ක්රියා කරන ආකාරය ගවේෂණය කිරීමට තරමක් වෙනස් කේත නියැදියක් භාවිතා කරමු. පහත දැක්වෙන්නේ ගොනුවක යැයි සිතමු foo.py.
# Suppose this is foo.py.
print("before import")
import math
print("before functionA")
def functionA():
print("Function A")
print("before functionB")
def functionB():
print("Function B {}".format(math.sqrt(100)))
print("before __name__ guard")
if __name__ == '__main__':
functionA()
functionB()
print("after __name__ guard")
විශේෂ විචල්යයන්
පයිතන් අතුරුමුහුණත ප්‍රභව ගොනුවක් කියවන විට, එය පළමුව විශේෂ විචල්යයන් කිහිපයක් අර්ථ දක්වයි. මෙම අවස්ථාවේ දී, අපි __name__විචල්යය ගැන සැලකිලිමත් වෙමු .
ඔබේ මොඩියුලය ප්රධාන වැඩසටහන වන විට
ඔබ ඔබේ මොඩියුලය (ප්‍රභව ගොනුව) ප්රධාන වැඩසටහන ලෙස ක්රියාත්මක කරන්නේ නම්, උදා
python foo.py
පරිවර්තකයා දෘඩ කේත "__main__"කරන ලද __name__නූල විචල්‍යයට පවරයි , එනම්
# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__"
ඔබේ මොඩියුලය වෙනත් අයෙකු විසින් ආනයනය කරන විට
අනෙක් අතට, වෙනත් මොඩියුලයක් ප්රධාන වැඩසටහන වන අතර එය ඔබේ මොඩියුලය ආනයනය කරයි යැයි සිතමු. මෙයින් අදහස් කරන්නේ ප්රධාන වැඩසටහනේ හෝ වෙනත් මොඩියුලයක ප්රධාන වැඩසටහන ආනයනය කරන ප්රකාශයක් ඇති බවයි:
# Suppose this is in some other main program.
import foo
පරිවර්තකයා ඔබේ foo.pyගොනුව සොයනු ඇත (වෙනත් ප්‍රභේද කිහිපයක් සෙවීම සමඟ), සහ එම මොඩියුලය ක්රියාත්මක කිරීමට පෙර, එය "foo"ආනයන ප්‍රකාශයේ සිට __name__විචල්‍යයට නම පවරනු ඇත , එනම්
# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"
මොඩියුලයේ කේතය ක්රියාත්මක කිරීම
විශේෂ විචල්යයන් සැකසූ පසු, පරිවර්තකයා මොඩියුලයේ ඇති සියලුම කේත ක්රියාත්මක කරයි, වරකට එක් ප්රකාශයක්. කේත නියැදිය සමඟ පැත්තේ තවත් කවුළුවක් විවෘත කිරීමට ඔබට අවශ්ය විය හැකි අතර එවිට ඔබට මෙම පැහැදිලි කිරීම සමඟ අනුගමනය කළ හැකිය.
සැමවිටම
එය නූල් මුද්‍රණය කරයි "before import"(උපුටා දැක්වීම් නොමැතිව).
එය mathමොඩියුලය පටවා විචල්‍යයක් ලෙස නම් mathකරයි. මෙය import mathපහත සඳහන් දෑ සමඟ ප්‍රතිස්ථාපනය කිරීමට සමාන වේ (සටහන __import__පයිතන් හි පහත් මට්ටමේ ශ්‍රිතයක් වන අතර එය නූලක් ගෙන සත්ය ආනයනය අවුලුවන):
# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")
එය නූල් මුද්‍රණය කරයි "before functionA".
එය defබ්ලොක් එක ක්රියාත්මක කරයි , ශ්‍රිත වස්තුවක් නිර්මාණය කරයි, පසුව එම ශ්‍රිත වස්තුව නම් විචල්‍යයකට පවරයි functionA.
එය නූල් මුද්‍රණය කරයි "before functionB".
එය දෙවන defවාරණය ක්රියාත්මක කරමින් තවත් ශ්‍රිත වස්තුවක් නිර්මාණය කර එය විචල්‍යයකට පවරයි functionB.
එය නූල් මුද්‍රණය කරයි "before __name__ guard".
ඔබේ මොඩියුලය ප්රධාන වැඩසටහන වන විට පමණි
- ඔබේ මොඩියුලය ප්රධාන වැඩසටහන නම්, එය
__name__සැබවින්ම සකසා ඇති බව පෙනෙනු ඇති "__main__"අතර එය ශ්‍රිත දෙක අමතයි, නූල් මුද්‍රණය කිරීම "Function A"සහ "Function B 10.0".
ඔබේ මොඩියුලය වෙනත් අයෙකු විසින් ආනයනය කළ විට පමණි
- ( ඒ වෙනුවට ) ඔබේ මොඩියුලය ප්රධාන වැඩසටහන නොව වෙනත් එකක් විසින් ආනයනය කරන ලද්දක් නම්, එසේ
__name__වනු ඇත "foo", නැත "__main__", එය ifප්‍රකාශයේ සිරුර මඟ හරිනු ඇත .
සැමවිටම
- එය
"after __name__ guard"අවස්ථා දෙකේදීම නූල මුද්‍රණය කරනු ඇත .
සාරාංශය
සාරාංශයක් ලෙස, අවස්ථා දෙකෙහි මුද්‍රණය කළ යුතු දේ මෙන්න:
# What gets printed if foo is the main program
before import
before functionA
before functionB
before __name__ guard
Function A
Function B 10.0
after __name__ guard
# What gets printed if foo is imported as a regular module
before import
before functionA
before functionB
before __name__ guard
after __name__ guard
එය මේ ආකාරයෙන් ක්රියාත්මක වන්නේ ඇයි?
ඕනෑම කෙනෙකුට මෙය අවශ්ය වන්නේ මන්දැයි ඔබ ස්වභාවයෙන්ම කල්පනා කළ හැකිය. හොඳයි, සමහර විට ඔබට .pyවෙනත් වැඩසටහන් සහ / හෝ මොඩියුලයන් මොඩියුලයක් ලෙස භාවිතා කළ හැකි ගොනුවක් ලිවීමට අවශ්ය වන අතර ප්රධාන වැඩසටහන ලෙසම ක්රියාත්මක කළ හැකිය. උදාහරණ:
ඔබේ මොඩියුලය පුස්තකාලයකි, නමුත් ඔබට අවශ්ය වන්නේ ස්ක්‍රිප්ට් මාදිලියක් තිබීමයි, එහිදී එය ඒකක පරීක්ෂණ හෝ නිරූපණයක් ක්රියාත්මක කරයි.
ඔබේ මොඩියුලය ප්රධාන වැඩසටහනක් ලෙස පමණක් භාවිතා කරයි, නමුත් එයට ඒකක පරීක්ෂණ කිහිපයක් ඇති අතර, පරීක්ෂණ රාමුව ක්රියාත්මක වන්නේ .pyඔබේ ස්ක්‍රිප්ට් වැනි ගොනු ආනයනය කිරීමෙන් සහ විශේෂ පරීක්ෂණ කාර්යයන් ක්රියාත්මක කිරීමෙනි . එය මොඩියුලය ආනයනය කරන නිසා එය ස්ක්‍රිප්ට් ධාවනය කිරීමට උත්සාහ කිරීම ඔබට අවශ්ය නැත.
ඔබේ මොඩියුලය බොහෝ දුරට ප්රධාන වැඩසටහනක් ලෙස භාවිතා කරයි, නමුත් එය උසස් පරිශීලකයින් සඳහා ක්‍රමලේඛ-හිතකාමී API ද සපයයි.
එම උදාහරණ වලින් ඔබ්බට, පයිතන් හි පිටපතක් ධාවනය කිරීම යනු මැජික් විචල්යයන් කිහිපයක් සැකසීම සහ පිටපත ආනයනය කිරීම පමණි. ස්ක්‍රිප්ට් එක "ධාවනය කිරීම" යනු ස්ක්‍රිප්ට් මොඩියුලය ආනයනය කිරීමේ අතුරු ආබාධයකි.
සිතුවිලි සඳහා ආහාර
ප්‍රශ්නය: මට බහුවිධ __name__පිරික්සුම් කොටස් තිබිය හැකිද? පිළිතුර: එසේ කිරීම අමුතු දෙයක්, නමුත් භාෂාව ඔබව නවත්වන්නේ නැහැ.
පහත දැක්වෙන්නේ යැයි සිතමු foo2.py. python foo2.pyවිධාන රේඛාවේ ඔබ පැවසුවහොත් කුමක් සිදුවේද ? මන්ද?
# Suppose this is foo2.py.
def functionA():
print("a1")
from foo2 import functionB
print("a2")
functionB()
print("a3")
def functionB():
print("b")
print("t1")
if __name__ == "__main__":
print("m1")
functionA()
print("m2")
print("t2")
- දැන්, ඔබ
__name__පිරික්සුම ඉවත් කළහොත් කුමක් සිදුවේදැයි සොයා බලන්න foo3.py:
# Suppose this is foo3.py.
def functionA():
print("a1")
from foo3 import functionB
print("a2")
functionB()
print("a3")
def functionB():
print("b")
print("t1")
print("m1")
functionA()
print("m2")
print("t2")
- පිටපතක් ලෙස භාවිතා කරන විට මෙය කරන්නේ කුමක්ද? මොඩියුලයක් ලෙස ආනයනය කරන විට?
# Suppose this is in foo4.py
__name__ = "__main__"
def bar():
print("bar")
print("before __name__ guard")
if __name__ == "__main__":
bar()
print("after __name__ guard")
if __name__ == "__main__":වාරණ තත්ත්වය අතහැර දමා / python, 3 වැනි දුර obsoleted? එය සඳහන් කරමින් මම යම් තොරතුරු සොයාගෙන ඇත.