පයිතන් පිටපතක පළමු පේළියේ මිනිසුන් #! / Usr / bin / env python shebang ලියන්නේ ඇයි?

එම රේඛාව නොමැතිව ලිපිගොනු එකම ලෙස ක්‍රියාත්මක වන බව මට පෙනේ.

ඔබ සතුව පයිතන් සංස්කරණ කිහිපයක් ස්ථාපනය කර ඇත්නම්, /usr/bin/envභාවිතා කරන පරිවර්තකයා ඔබේ පරිසරයේ පළමුවැන්න බව සහතික කරයි $PATH. විකල්පය වනුයේ වැනි දෙයක් දෘඩ කේතනය කිරීමයි #!/usr/bin/python; ඒක හරි, නමුත් නම්යශීලීයි.

යුනික්ස් හි, අර්ථ නිරූපණය කිරීමට අදහස් කරන ක්‍රියාත්මක කළ හැකි ගොනුවකට #!පළමු පේළියේ ආරම්භයේ සිට, පසුව පරිවර්තකයා (සහ එයට අවශ්‍ය ඕනෑම කොඩි) භාවිතා කිරීමෙන් කුමන පරිවර්තකය භාවිතා කළ යුතුද යන්න දැක්විය හැකිය.

ඔබට වෙනත් වේදිකා ගැන කතා කරන්නේ නම්, ඇත්ත වශයෙන්, මෙම නීතිය අදාළ නොවේ (නමුත් "shebang රේඛාව" කිසිදු හානියක් කරන්නේ, ඔබ මෙතෙක් වේදිකාවක් බව තිර රචනය පිටපත් නම් උපකාර කරන බව සමග එවැනි ලිනක්ස්, මැක් ලෙස, Unix පදනම , ආදිය).

එය ෂෙබාං රේඛාව ලෙස හැඳින්වේ . ලෙස විකිපීඩියා, නිදහස් විශ්වකෝෂය ප්රවේශය පැහැදිලි :

පරිගණනයේදී, ෂෙබාං (හැෂ්බෑන්ග්, හැෂ්ප්ලිං, පවුම් බැන්ග් හෝ ක්‍රන්ච්බෑන්ග් ලෙසද හැඳින්වේ) "#!" පෙළ ගොනුවක පළමු පේළිය ලෙස පරිවර්තක විධානයක පළමු අක්ෂර දෙක වන විට. යුනික්ස් වැනි මෙහෙයුම් පද්ධතියක, ක්‍රමලේඛ පැටවුම මෙම අක්ෂර දෙක තිබීම ගොනුව ස්ක්‍රිප්ට් එකක් බවට ඇඟවීමක් ලෙස සලකන අතර ගොනුවේ පළමු පේළියේ ඉතිරි කොටස නියම කර ඇති පරිවර්තකය භාවිතා කර එම ස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීමට උත්සාහ කරයි.

යුනික්ස් නිති අසන ප්‍රශ්න ඇතුළත් කිරීම ද බලන්න .

වින්ඩෝස් හි පවා, ෂෙබාං රේඛාව මඟින් පරිවර්තකය ක්‍රියාත්මක කළ යුතු දැයි තීරණය නොකෙරේ, ඔබට ෂෙබාං රේඛාවේ සඳහන් කිරීමෙන් පරිවර්තකයාට විකල්ප ලබා දිය හැකිය. සාමාන්‍ය ෂෙබාං රේඛාවක් එක්-ස්ක්‍රිප්ට් එකක තබා ගැනීම ප්‍රයෝජනවත් බව මට පෙනේ (SO පිළිබඳ ප්‍රශ්නවලට පිළිතුරු සපයන විට මා ලියන ඒවා වැනි), එබැවින් මට ඒවා වින්ඩෝස් සහ ආර්ච් ලිනක්ස් යන දෙකින්ම ඉක්මනින් පරීක්ෂා කළ හැකිය .

මෙම env උපයෝගිතා ඔබ යන මාවතේ විධාන පතා සඳහා අවකාශ ලබා දෙයි:

ඉතිරිව ඇති පළමු තර්කය මඟින් ආයාචනා කිරීම සඳහා වැඩසටහනේ නම නියම කරයි; PATHපරිසර විචල්‍යයට අනුව එය සොයනු ලැබේ . ඉතිරිව ඇති ඕනෑම තර්කයක් එම වැඩසටහනේ තර්ක ලෙස සම්මත වේ.

අනෙක් පිළිතුරු ගැන ටිකක් පුළුල් කරමින්, /usr/bin/envෂෙබාං රේඛා අනවශ්‍ය ලෙස භාවිතා කිරීමෙන් ඔබේ විධාන රේඛා ස්ක්‍රිප්ට් කරදරයට පත්විය හැකි ආකාරය පිළිබඳ කුඩා උදාහරණයක් මෙන්න :

$ /usr/local/bin/python -V
Python 2.6.4
$ /usr/bin/python -V
Python 2.5.1
$ cat my_script.py 
#!/usr/bin/env python
import json
print "hello, json"
$ PATH=/usr/local/bin:/usr/bin
$ ./my_script.py 
hello, json
$ PATH=/usr/bin:/usr/local/bin
$ ./my_script.py 
Traceback (most recent call last):
  File "./my_script.py", line 2, in <module>
    import json
ImportError: No module named json

Json මොඩියුලය පයිතන් 2.5 හි නොපවතී.

එවැනි ගැටළුවකින් ආරක්ෂා වීමට එක් ක්‍රමයක් නම් බොහෝ පයිතන් සමඟ සාමාන්‍යයෙන් ස්ථාපනය කර ඇති අනුවාදිත පයිතන් විධාන නාම භාවිතා කිරීමයි:

$ cat my_script.py 
#!/usr/bin/env python2.6
import json
print "hello, json"

ඔබට පයිතන් 2.x සහ පයිතන් 3.x අතර වෙනස හඳුනා ගැනීමට අවශ්‍ය නම්, මෑතකදී නිකුත් කළ පයිතන් 3 ද python3නමක් සපයයි :

$ cat my_script.py 
#!/usr/bin/env python3
import json
print("hello, json")

පයිතන් ස්ක්‍රිප්ට් ධාවනය කිරීම සඳහා, අපි ෂෙල් එකට කරුණු තුනක් පැවසිය යුතුය:

1. ගොනුව ස්ක්‍රිප්ට් එකක් බව
2. ස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීමට අපට අවශ්‍ය කුමන පරිවර්තකයද?
3. ඉහත පරිවර්තකයාගේ මාර්ගය

ෂෙබාං #!ඉටු කරයි (1.). මෙම shebang සමඟ ආරම්භ #වන නිසා #චරිතය බොහෝ විධානාවලි භාෂාවන් තුළ ප්රතිචාරයක් මාකර් වේ. එබැවින් ෂෙබාං රේඛාවේ අන්තර්ගතය පරිවර්තකයා විසින් ස්වයංක්‍රීයව නොසලකා හරිනු ලැබේ.

මෙම envවිධානය භාවිතා කිරීමෙන් අරමුණු (2.) සහ (3.). "ගුරුත්වාකර්ෂණය" උපුටා දැක්වීමට

envවිධානයෙහි පොදු භාවිතයක් වන්නේ පරිවර්තකයන් දියත් කිරීමයි, එය දියත් කිරීමට කියනු ලබන විධානය සඳහා env $ PATH සොයනු ඇත. ෂෙබාං රේඛාවට නිරපේක්ෂ මාර්ගයක් නියම කිරීමට අවශ්‍ය වන නිසා සහ විවිධ පරිවර්තකයන්ගේ පිහිටීම (පර්ල්, බැෂ්, පයිතන්) බොහෝ වෙනස් විය හැකි බැවින්, භාවිතා කිරීම සාමාන්‍ය දෙයකි:

#!/usr/bin/env perl  එය / bin / perl, / usr / bin / perl, / usr / local / bin / perl, / usr / local / pkg / perl, / fileserver / usr / bin / perl, හෝ / home යන්න අනුමාන කිරීමට උත්සාහ කරනවා වෙනුවට / MrDaniel / usr / bin / perl පරිශීලක පද්ධතියේ ...

අනෙක් අතට, env සෑම විටම පාහේ / usr / bin / env හි ඇත. (එසේ නොවන අවස්ථාවන්හිදී හැර; සමහර පද්ධති / bin / env භාවිතා කළ හැකිය, නමුත් එය තරමක් දුර්ලභ සිදුවීමක් වන අතර එය සිදුවන්නේ ලිනක්ස් නොවන පද්ධති වල පමණි.)

මෙම execලිනක්ස් කර්නලයේ පද්ධතිය ඇමතුමක් shebangs අවබෝධ ( #!) natively

ඔබ කඩාවැටෙන විට:

./something

ලිනක්ස් හි, මෙය execපද්ධති ඇමතුම මාර්ගය සමඟ අමතයි ./something.

කර්නලයේ මෙම රේඛාව වෙත යොමු කරන ලද ගොනුව වෙත කැඳවනු ලැබේ exec: https://github.com/torvalds/linux/blob/v4.8/fs/binfmt_script.c#L25

if ((bprm->buf[0] != '#') || (bprm->buf[1] != '!'))

එය ගොනුවේ මුල් බයිට් කියවන අතර ඒවා සංසන්දනය කරයි #!.

සංසන්දනය සත්‍ය නම්, ඉතිරි පේළිය ලිනක්ස් කර්නලය මඟින් විග්‍රහ කරනු ලැබේ, එමඟින් පළමු තර්කය ලෙස execමාර්ගය /usr/bin/env pythonසහ වත්මන් ගොනුව සමඟ තවත් ඇමතුමක් ලබා දෙයි :

/usr/bin/env python /path/to/script.py

#අදහස් දැක්වීමේ චරිතයක් ලෙස භාවිතා කරන ඕනෑම ස්ක්‍රිප්ටින් භාෂාවක් සඳහා මෙය ක්‍රියා කරයි .

ඔව්, ඔබට මෙය සමඟ අනන්ත පුඩුවක් සෑදිය හැකිය:

printf '#!/a\n' | sudo tee /a
sudo chmod +x /a
/a

බාෂ් දෝෂය හඳුනා ගනී:

-bash: /a: /a: bad interpreter: Too many levels of symbolic links

#! මිනිසුන්ට කියවිය හැකි දෙයක් බවට පත්වේ, නමුත් එය අවශ්‍ය නොවේ.

ගොනුව විවිධ බයිට් වලින් ආරම්භ කළේ නම්, execපද්ධති ඇමතුම වෙනත් හෑන්ඩ්ලර් භාවිතා කරයි. අනෙක් වඩාත්ම වැදගත් බිල්ට් හෑන්ඩ්ලර් වන්නේ ඊඑල්එෆ් ක්‍රියාත්මක කළ හැකි ලිපිගොනු සඳහා ය: https://github.com/torvalds/linux/blob/v4.8/fs/binfmt_elf.c#L1305 බයිට් සඳහා පරික්ෂා කරයි 7f 45 4c 46(එය ද මිනිසුන් වේ කියවිය හැකි .ELF). /bin/lsඊඑල්එෆ් ක්‍රියාත්මක කළ හැකි පළමු බයිට් 4 කියවීමෙන් එය තහවුරු කරමු :

head -c 4 "$(which ls)" | hd 

ප්‍රතිදානය:

00000000  7f 45 4c 46                                       |.ELF|
00000004                                                                 

එබැවින් කර්නලය එම බයිට් දුටු විට, එය ඊඑල්එෆ් ගොනුව ගෙන එය නිවැරදිව මතකයට දමා එය සමඟ නව ක්‍රියාවලියක් ආරම්භ කරයි. මෙයද බලන්න: කර්නලයට ලිනක්ස් යටතේ ක්‍රියාත්මක කළ හැකි ද්විමය ගොනුවක් ලැබෙන්නේ කෙසේද?

අවසාන වශයෙන්, ඔබට binfmt_miscයාන්ත්‍රණය සමඟ ඔබේම ෂෙබාං හසුරුවන්නන් එකතු කළ හැකිය . උදාහරණයක් ලෙස, ඔබට ගොනු සඳහා අභිරුචි හසුරුවන්නෙකු.jar එක් කළ හැකිය . මෙම යාන්ත්‍රණය ගොනු දිගුව මඟින් හසුරුවන්නන්ට පවා සහාය දක්වයි. තවත් යෙදුමක් වන්නේ QEMU සමඟ වෙනස් ගෘහ නිර්මාණ ශිල්පයක විනිවිද පෙනෙන ලෙස ක්‍රියාත්මක කළ හැකි වීමයි .

මම හිතන්නේ නැහැ POSIX : කෙසේ වෙතත් විශේෂයෙන් නියම shebangs https://unix.stackexchange.com/a/346214/32558 , එය තර්කයක් කොටස් මත ද ස්වරූපයෙන් දී සඳහන් නොවේ නමුත් "ක්රියාත්මක පිටපත් පද්ධතිය මඟින් හැක දෙයක් සහාය නම් සිදුවන්න ". කෙසේ වෙතත් macOS සහ FreeBSD ද එය ක්‍රියාත්මක කරන බව පෙනේ.

PATH සෙවුම් අභිප්‍රේරණය

බොහෝ විට, ෂෙබාං වල පැවැත්ම සඳහා එක් විශාල අභිප්‍රේරණයක් නම්, ලිනක්ස් වලදී, අපට බොහෝ විට අවශ්‍ය වන්නේ විධාන ක්‍රියාත්මක PATHකිරීමට ය:

basename-of-command

වෙනුවට:

/full/path/to/basename-of-command

නමුත් ෂෙබාං යාන්ත්‍රණය නොමැතිව ලිනක්ස් එක් එක් වර්ගයේ ගොනුවක් දියත් කරන්නේ කෙසේදැයි දැන ගන්නේ කෙසේද?

විධාන විස්තාරණය දෘඩ කේතනය කිරීම:

 basename-of-command.py

හෝ සෑම පරිවර්තකයෙකුටම PATH සෙවීම ක්‍රියාත්මක කිරීම:

python basename-of-command

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

ෂෙබාන්ග්ස් මෙම ගැටළුව ලස්සනට විසඳයි.

සමහර විට ඔබේ ප්‍රශ්නය මේ අර්ථයෙන් විය හැකිය:

ඔබට භාවිතා කිරීමට අවශ්‍ය නම්: $python myscript.py

ඔබට එම රේඛාව කිසිසේත් අවශ්‍ය නොවේ. පද්ධතිය පයිතන් අමතනු ඇති අතර පසුව පයිතන් පරිවර්තකය ඔබේ ස්ක්‍රිප්ට් ක්‍රියාත්මක කරයි.

නමුත් ඔබ භාවිතා කිරීමට අදහස් කරන්නේ නම්: $./myscript.py

එය සාමාන්‍ය වැඩසටහනක් හෝ බැෂ් ස්ක්‍රිප්ට් එකක් ලෙස කෙලින්ම අමතන්නේ නම්, එය ක්‍රියාත්මක කිරීමට කුමන වැඩසටහන භාවිතා කරනවාද යන්න සඳහන් කිරීමට ඔබට එම රේඛාව ලිවිය යුතුය (තවද එය ක්‍රියාත්මක කළ හැකි chmod 755)

තාක්ෂණික වශයෙන්, පයිතන්හි මෙය විවරණ රේඛාවක් පමණි.

මෙම රේඛාව ඔබ py කේත රචනය ක්රියාත්මක නම් පමණක් භාවිතා වේ ෂෙල් එකේ සිට (විධාන රේඛාවේ සිට). මෙය " ෂෙබාං !", එය පයිතන් ස්ක්‍රිප්ට් සමඟ පමණක් නොව විවිධ අවස්ථා වලදී භාවිතා කරයි.

මෙන්න, එය ෂෙල්ට උපදෙස් දෙන්නේ පයිතන්ගේ නිශ්චිත අනුවාදයක් ආරම්භ කිරීමට (ගොනුවේ ඉතිරි කොටස බලා ගැනීමට).

මෙය කිරීමට ප්‍රධාන හේතුව වන්නේ මෙහෙයුම් පද්ධති පරිසරයන් හරහා ස්ක්‍රිප්ට් අතේ ගෙන යා හැකි වීමයි.

උදාහරණයක් ලෙස mingw යටතේ, පයිතන් ස්ක්‍රිප්ට් භාවිතා කරයි:

#!/c/python3k/python 

ග්නූ / ලිනක්ස් බෙදා හැරීම යටතේ එය එක්කෝ:

#!/usr/local/bin/python 

හෝ

#!/usr/bin/python

සහ සියලු දෙනාගේම (OS / X) හොඳම වාණිජ යුනික්ස් sw / hw පද්ධතිය යටතේ, එය:

#!/Applications/MacPython 2.5/python

හෝ FreeBSD හි:

#!/usr/local/bin/python

කෙසේ වෙතත්, මෙම සියලු වෙනස්කම් භාවිතා කිරීමෙන් ස්ක්‍රිප්ට් අතේ ගෙන යා හැකිය:

#!/usr/bin/env python

බොහෝ විට මග හැරී ඇති එක් දෙයක් අවධාරණය කිරීම අර්ථවත් වන අතර එමඟින් ක්ෂණික අවබෝධය වළක්වා ගත හැකිය. ඔබ pythonටර්මිනලය ටයිප් කරන විට සාමාන්‍යයෙන් සම්පූර්ණ මාර්ගයක් ලබා නොදේ. ඒ වෙනුවට, ක්‍රියාත්මක කළ හැකි PATHපරිසර විචල්‍යය දෙස බලයි . අනෙක් අතට, ඔබට සෘජුවම පයිතන් වැඩසටහනක් ක්‍රියාත්මක කිරීමට අවශ්‍ය වූ විට, /path/to/app.pyකුමන පරිවර්තකය භාවිතා කළ යුතු දැයි ෂෙල් එකට පැවසිය යුතුය ( හැෂ්බෑන්ග් හරහා , අනෙක් දායකයින් ඉහත විස්තර කරන්නේ කුමක්ද).

හෂ්බෑන්ග් පරිවර්තකයෙකු වෙත සම්පූර්ණ මාවතක් අපේක්ෂා කරයි . මේ අනුව කෙළින්ම ඔබේ Python වැඩසටහන ක්රියාත්මක කිරීමට ඔබ විශේෂයෙන් ක භාවිතය සලකා, සැලකිය යුතු වෙනස් කරනු Python ද්වීමය සම්පූර්ණ මාර්ගය ලබා ඇති virtualenv . අතේ ගෙන යා හැකි බව ආමන්ත්‍රණය කිරීම සඳහා උපක්‍රමය /usr/bin/envභාවිතා කරයි. දෙවැන්න මුලින් අදහස් කරන්නේ පරිසරය තැනින් තැන වෙනස් කර එහි විධානයක් ක්‍රියාත්මක කිරීමයි. කිසිදු වෙනස් කිරීමක් ලබා නොදුන් විට එය වත්මන් පරිසරය තුළ විධානය ක්‍රියාත්මක PATHකරයි.

ප්‍රභවය යුනික්ස් ස්ටැක්එක්ස්චේන්ජ් වෙතින්

මෙය ෂෙල් සම්මුතියක් වන අතර එය තිර රචනය ක්‍රියාත්මක කළ හැකි වැඩසටහනට ෂෙල්ට පවසයි.

#! / usr / bin / env python

පයිතන් ද්විමය වෙත යන මාර්ගයකට විසඳයි.

එය නිර්දේශිත ක්‍රමයක්, ප්‍රලේඛනයකින් යෝජනා කර ඇත:

2.2.2. ක්‍රියාත්මක කළ හැකි පයිතන් පිටපත්

BSD'ish යුනික්ස් පද්ධති වල, පයිතන් ස්ක්‍රිප්ට් රේඛාව තැබීමෙන් ෂෙල් ස්ක්‍රිප්ට් මෙන් කෙලින්ම ක්‍රියාත්මක කළ හැකිය.

#! /usr/bin/env python3.2

http://docs.python.org/py3k/tutorial/interpreter.html#executable-python-scripts වෙතින්

Virtualenv භාවිතයෙන් ඔබට මෙම ගැටළුව උත්සාහ කළ හැකිය

මෙන්න test.py

#! /usr/bin/env python
import sys
print(sys.version)

අතථ්‍ය පරිසරයන් සාදන්න

virtualenv test2.6 -p /usr/bin/python2.6
virtualenv test2.7 -p /usr/bin/python2.7

එක් එක් පරිසරය සක්‍රිය කර වෙනස්කම් පරීක්ෂා කරන්න

echo $PATH
./test.py

එය ඔබට භාවිතා කිරීමට අවශ්‍ය පරිවර්තකය නියම කරයි. මෙය වටහා ගැනීම සඳහා, ටර්මිනලය හරහා ගොනුවක් සාදන්න touch test.py, ඉන්පසු පහත දැක්වෙන ගොනුවට ටයිප් කරන්න:

#!/usr/bin/env python3
print "test"

හා කරන්න chmod +x test.pyඔබගේ ස්ක්රිප්ට් ක්රියාත්මක කළ යුතු බව ය. මෙයින් පසු ඔබ ./test.pyදෝෂයක් ලබා ගත යුතුය:

  File "./test.py", line 2
    print "test"
               ^
SyntaxError: Missing parentheses in call to 'print'

python3 මුද්‍රණ ක්‍රියාකරුට සහාය නොදක්වන බැවිනි.

දැන් ඉදිරියට ගොස් ඔබේ කේතයේ පළමු පේළිය පහත පරිදි වෙනස් කරන්න:

#!/usr/bin/env python2

එය මුද්රණය, වැඩ කරන්නම් testpython2 මුද්රිත ක්රියාකරු සහාය නිසා stdout කිරීමට. ඉතින්, දැන් ඔබ ස්ක්‍රිප්ට් පරිවර්තකයන් අතර මාරු වන්නේ කෙසේදැයි ඉගෙන ගෙන ඇත.

එම රේඛාව නොමැතිව ලිපිගොනු එකම ලෙස ක්‍රියාත්මක වන බව මට පෙනේ.

එසේ නම්, සමහර විට ඔබ වින්ඩෝස් හි පයිතන් වැඩසටහන ක්‍රියාත්මක කරන්නේද? වින්ඩෝස් එම රේඛාව භාවිතා නොකරයි - ඒ වෙනුවට, එය ගොනු දිගුව හා සම්බන්ධ වැඩසටහන ක්‍රියාත්මක කිරීමට ගොනු නාම දිගුව භාවිතා කරයි.

කෙසේ වෙතත් , 2011 දී, වින්ඩෝස් සඳහා මෙම ලිනක්ස් හැසිරීම අනුකරණය කරන (තරමක් දුරට) "පයිතන් දියත් කිරීමක්" සංවර්ධනය කරන ලදී. මෙය සීමා වී ඇත්තේ කුමන පයිතන් පරිවර්තකය ධාවනය කරන්නේද යන්න තෝරා ගැනීමට පමණි - උදා: දෙකම ස්ථාපනය කර ඇති පද්ධතියක පයිතන් 2 සහ පයිතන් 3 අතර තෝරා ගැනීම. දියත් කිරීම විකල්පයක් ලෙස py.exeපයිතන් ස්ථාපනය මඟින් ස්ථාපනය කර ඇති අතර එය .pyගොනු සමඟ සම්බන්ධ කළ හැකි වන අතර එමඟින් දියත් කරන්නා එම රේඛාව පරීක්ෂා කර නිශ්චිත පයිතන් පරිවර්තක අනුවාදය දියත් කරයි.

මෙය "සැබෑ" පිළිතුරකට වඩා historical තිහාසික තොරතුරු ලෙස අදහස් කෙරේ.

ඔබ වැනි සිය නිර්මාණකරුවන් සියලු දේ ක්රියාත්මක කිරීමට එහිදී ඔවුන්ගේ ම මතය විය, සමහරවිට, Python, perl බසට ලං, බෑෂ්, හෝ වෙනත් GNU / විවෘත මෘදුකාංග දේවල් ගොඩක් ඇතුළත් වුණේ නැහැ මෙහෙයුම් පද්ධති unix බොහෝ සිටියහ දවසේ දී බව නැවත මතක තබා ගන්න සියලු දී .

විවිධ ලිනක්ස් බෙදාහැරීම් සම්බන්ධයෙන් පවා මෙය සත්‍යයක් විය. ලිනක්ස් හි - පෙර-එෆ්එච්එස් [1] - ඔබට / usr / bin / හෝ / usr / local / bin / හි පයිතන් තිබිය හැක. නැතහොත් එය ස්ථාපනය කර නොතිබෙන්නට පුළුවන, එබැවින් ඔබ ඔබේම දෑ සාදා එය ~ / bin තුළට දමන්න

සොලාරිස් යනු මා වැඩ කළ නරකම දෙයයි, අර්ධ වශයෙන් බර්ක්ලි යුනික්ස් සිට සිස්ටම් වී වෙත මාරුවීම. ඔබට / usr /, / usr / local /, / usr / ucb, / opt / ආදී දේවල් සමඟ සුළං හමන්නට පුළුවන. සමහර ඇත්තටම දිගු මාර්ග. සන්ෆ්‍රීවෙයාර්.කොම් හි සෑම පැකේජයක්ම තමන්ගේම නාමාවලියක ස්ථාපනය කර ඇති ආකාරය පිළිබඳ මට මතකයන් ඇත, නමුත් එය ද්විමය / usr / bin බවට සමමුහුර්ත කර තිබේද නැද්ද යන්න මට මතක නැත.

ඔහ්, සමහර විට / usr / bin එන්එෆ්එස් සේවාදායකයක විය [2].

එබැවින් මේ envසඳහා වැඩ කිරීම සඳහා උපයෝගීතාව වර්ධනය කරන ලදී.

එවිට ඔබට ලිවිය හැකි #!/bin/env interpreterඅතර මාර්ගය නිසි ලෙස පවතින තාක් කල් දේවල් ක්‍රියාත්මක වීමට සාධාරණ අවස්ථාවක් තිබුණි . ඇත්ත වශයෙන්ම, සාධාරණ අර්ථයක් (පයිතන් සහ පර්ල් සඳහා) ඔබ සුදුසු පාරිසරික විචල්‍යයන් ද සකසා ඇති බව. Bash / ksh / zsh සඳහා එය ක්‍රියාත්මක විය.

මෙය වැදගත් වූයේ මිනිසුන් ෂෙල් ස්ක්‍රිප්ට් (පර්ල් සහ පයිතන් වැනි) වටා ගමන් කරන නිසා සහ ඔබේ Red Hat ලිනක්ස් වැඩපොළේ / usr / bin / python කේතගත කිරීමට අවශ්‍ය නම් එය SGI එකක නරක අතට හැරෙනු ඇත ... හොඳයි, නැත. , මම හිතන්නේ IRIX විසින් පයිතන් නියම තැනට දමා ඇත. නමුත් ස්පාර්ක් දුම්රිය ස්ථානයක එය කිසිසේත් ක්‍රියාත්මක නොවනු ඇත.

මට මගේ ස්පාර්ක් ස්ථානය මඟ හැරී ඇත. නමුත් ගොඩක් නොවේ. හරි, දැන් ඔයා මාව ඊ-බේ එකේ ට්‍රෝලර් කරනවා. බැස්ටේජ්.

[1] ගොනු පද්ධති ධූරාවලිය ප්‍රමිතිය. https://en.wikipedia.org/wiki/Filesystem_Hierarchy_Standard

[2] ඔව්, සමහර විට මිනිසුන් තවමත් එවැනි දේ කරති. නැහැ, මම මගේ පටියේ ටර්නිප් හෝ ලූනු පැළඳ සිටියේ නැහැ.

ඔබ ඔබේ ස්ක්‍රිප්ට් අතථ්‍ය පරිසරයක ධාවනය කරන්නේ නම්, කියන්න venv, එවිට which pythonවැඩ කරන අතරතුර ක්‍රියාත්මක කිරීම venvපයිතන් පරිවර්තකයට මාර්ගය පෙන්වනු ඇත:

~/Envs/venv/bin/python

අථත්ය පරිසරයේ නම පයිතන් පරිවර්තකය වෙත යන මාවතේ කාවැදී ඇති බව සලකන්න . එමනිසා, ඔබේ ස්ක්‍රිප්ටයේ මෙම මාර්ගය දෘ c කේත කිරීම ගැටළු දෙකක් ඇති කරයි:

• ඔබ ස්ක්‍රිප්ට් එක ගබඩාවකට උඩුගත කරන්නේ නම්, ඔබ අනෙක් පරිශීලකයින්ට එකම අථත්‍ය පරිසර නාමයක් ඇති කිරීමට බල කරයි. මෙය ඔවුන් මුලින්ම ගැටලුව හඳුනා ගන්නේ නම් ය.
• ඔබට වෙනත් අථත්‍ය පරිසරයන් තුළ අවශ්‍ය සියලුම පැකේජ තිබුනද ඔබට බහු අථත්‍ය පරිසරයන් හරහා ස්ක්‍රිප්ට් ධාවනය කිරීමට නොහැකි වනු ඇත .

එබැවින්, ජොනතන්ගේ පිළිතුරට එකතු කිරීම සඳහා , පරිපූර්ණ ෂෙබාං යනු #!/usr/bin/env pythonමෙහෙයුම් පද්ධති හරහා අතේ ගෙන යා හැකි දේ සඳහා පමණක් නොව අථත්‍ය පරිසරයන් හරහා අතේ ගෙන යා හැකි හැකියාවයි !

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

සමහර බෙදාහැරීම් දැන් pythonටික කලකට සමමුහුර්ත කර python3ඇත - pythonපැවැත්ම මත රඳා නොසිටින්න python2.

PEP 394 මෙය අවධාරණය කරයි :

වේදිකා අතර ඇති වෙනස්කම් ඉවසා සිටීම සඳහා, පයිතන් පරිවර්තකය කැඳවීමට අවශ්‍ය සියලුම නව කේතයන් පයිතන් නියම නොකළ යුතුය, නමුත් පයිතන් 2 හෝ පයිතන් 3 (හෝ වඩාත් නිශ්චිත python2.x සහ python3.x අනුවාදයන් සඳහන් කළ යුතුය; සංක්‍රමණ සටහන් බලන්න ). . මෙම වෙනස ෂෙබාන්ග්ස් වලින් කළ යුතුය, ෂෙල් ස්ක්‍රිප්ට් එකකින් ආයාචනා කරන විට, පද්ධති () ඇමතුම හරහා ආයාචනා කරන විට හෝ වෙනත් සන්දර්භයක් තුළ ආයාචනා කරන විට.

ඔබට පයිතන් බහු සංස්කරණ ඇති විට වැඩසටහන ක්‍රියාත්මක කළ යුත්තේ කුමන පයිතන් අනුවාදයද යන්න එය පරිවර්ථකයාට කියයි.

එය ඔබට භාවිතා කිරීමට බලාපොරොත්තු වන ක්‍රියාත්මක කළ හැකි දේ තෝරා ගැනීමට ඉඩ දෙයි; ඔබට බහු පයිතන් ස්ථාපනයන් සහ විවිධ මොඩියුලයන් ඇති අතර ඒවා තෝරා ගැනීමට කැමති නම් එය ඉතා පහසුය. උදා

#!/bin/sh
#
# Choose the python we need. Explanation:
# a) '''\' translates to \ in shell, and starts a python multi-line string
# b) "" strings are treated as string concat by python, shell ignores them
# c) "true" command ignores its arguments
# c) exit before the ending ''' so the shell reads no further
# d) reset set docstrings to ignore the multiline comment code
#
"true" '''\'
PREFERRED_PYTHON=/Library/Frameworks/Python.framework/Versions/2.7/bin/python
ALTERNATIVE_PYTHON=/Library/Frameworks/Python.framework/Versions/3.6/bin/python3
FALLBACK_PYTHON=python3

if [ -x $PREFERRED_PYTHON ]; then
    echo Using preferred python $ALTERNATIVE_PYTHON
    exec $PREFERRED_PYTHON "$0" "$@"
elif [ -x $ALTERNATIVE_PYTHON ]; then
    echo Using alternative python $ALTERNATIVE_PYTHON
    exec $ALTERNATIVE_PYTHON "$0" "$@"
else
    echo Using fallback python $FALLBACK_PYTHON
    exec python3 "$0" "$@"
fi
exit 127
'''

__doc__ = """What this file does"""
print(__doc__)
import platform
print(platform.python_version())

කුමන පයිතන් සම්පාදකය භාවිතා කළ යුතුද යන්න රේඛාව #!/bin/bash/python3හෝ #!/bin/bash/pythonනියම කරයි. ඔබට බහු පයිතන් අනුවාද ස්ථාපනය කර තිබිය හැක. උදාහරණයක් ලෙස,
a.py:

#!/bin/bash/python3
print("Hello World")

යනු python3 ස්ක්‍රිප්ට් එකක් වන අතර
b.py:

#!/bin/bash/python
print "Hello World"

පයිතන් 2.x ස්ක්‍රිප්ට් එකක්
මෙම ගොනුව ක්‍රියාත්මක කිරීම සඳහා ./a.pyහෝ ./b.pyභාවිතා කිරීම සඳහා, ඔබ විසින් ගොනු ක්‍රියාත්මක කිරීමේ වරප්‍රසාද ලබා දීමට පෙර ලබා දිය යුතුය, එසේ නොමැතිනම් ක්‍රියාත්මක කිරීම Permission deniedදෝෂයකට තුඩු දෙනු ඇත .
ක්‍රියාත්මක කිරීමට අවසර ලබා දීම සඳහා,

chmod +x a.py

මෙය පිටපතට කියන්නේ පයිතන් නාමාවලිය තිබෙන තැන!

#! /usr/bin/env python