py文件預編譯

⑴ Linux下如何編譯python的*.py

直接使用命令跟上文件名就可以，如：
python test.py

⑵ C語言既可以編譯執行又可以解釋執行嗎 編譯執行怎麼解釋 解釋執行又怎麼解釋

C 語言程序僅可以解釋執行。

解釋程序是將源程序(如BASIC)作為輸入，解釋一句後就提交計算機執行一句，並不形成目標程序。編譯程序是把高級語言(如FORTRAN、COBOL、Pascal、C等)源程序作為輸入，進行翻譯轉換，產生出機器語言的目標程序，然後再讓計算機執行這個目標程序，得到計算結果。

相對於編譯性語言，其優點是可移植性好，只要有解釋器環境，程序就可以在不同的操作系統上運行。

缺點是代碼需要有專門的解釋器，在程序運行時，除要給用戶程序本身分配內存空間外，解釋器也佔用系統資源，所以其運行速度較慢。另外，也很難達到像C、C++那樣操作系統底層操作的目的。

解釋型語言常用於，一是對運行速度要求不高（如一些網頁腳本等）的場合，二是對跨平台（操作系統的兼容性）有要求的場合。

(2)py文件預編譯擴展閱讀

1、Python和Java語言，專門有一個解釋器能夠直接執行Python程序，每個語句都是執行的時候才翻譯。

2、Python代碼在運行前，會先編譯成中間代碼，每個 .py 文件將被換轉成pyc 文件，pyc 就是一種位元組碼文件，它是與平台無關的中間代碼。不管放在 Windows 還是 Linux 平台都可以執行，運行時將由虛擬機逐行把位元組碼翻譯成目標代碼。

⑶ 解釋性編程語言是執行的時候翻譯，比如python,那麼如果我用軟體把py文件製成exe文件，是不是

能生成exe並不代表什麼，py轉為exe之類的工具原理都差不多，都是對py的代碼進行預編譯，然後創建一個小型的python運行環境（一般會包括啟動用的exe、python相關的dll和編譯後的文件），在執行時仍然會由它自己的這個環境來負責解釋執行代碼，而並不是真正的生成了直接的機器語言。

⑷ 為什麼編譯的Python模塊，但不是腳本正在運行

文件是在導入編譯。 這不是一個安全的事情。 這僅僅是如果你將其導入蟒蛇保存輸出。 看到這個帖子由Fredrik Lundh開發上Effbot。

>>>import main
# main.pyc is created

當運行一個腳本巨蟒將不使用* .pyc文件的文件。 如果你有你想要你的腳本一些其他的原因，預編譯可以使用compileall模塊。

python -m compileall .

compileall用法

python -m compileall --help
option --help not recognized
usage: python compileall.py [-l] [-f] [-q] [-d destdir] [-x regexp] [directory ...]
-l: don't recurse down
-f: force rebuild even if timestamps are up-to-date
-q: quiet operation
-d destdir: purported directory name for error messages
if no directory arguments, -l sys.path is assumed
-x regexp: skip files matching the regular expression regexp
the regexp is searched for in the full path of the file

回答以下問題編輯

• 如果響應是潛在的磁碟許可權的目錄main.py，為什麼Python的編譯模塊？

  模塊和腳本將被視為相同。 進口是什麼觸發要保存的輸出。

• 如果原因是好處將是最小的，可以考慮的情況時，該腳本將被用於大量的時間（諸如在一個CGI應用程序）。

  使用compileall不解決這個問題。 由蟒蛇執行的腳本將不使用*.pyc，除非明確要求。 這有負面影響，深受格倫·梅納德在他的回答說。

  CGI應用程序的給出的例子確實應該使用像FastCGI的技術來解決。 如果你想消除編譯腳本的開銷，可能要消除啟動蟒蛇太大，何況資料庫連接開銷的開銷。

  光引導腳本可以用來甚至python -c "import script"，但這些都值得商榷的風格。

格倫·梅納德提供一些靈感來糾正和改進這個答案。

似乎沒有人想這樣說，但我敢肯定的答案很簡單：有這種行為沒有堅實的理由。

所有到目前為止所提出的理由基本上是不正確的：

• 沒有什麼特別的主文件。 它作為一個模塊載入，並顯示了sys.moles像任何其他模塊。 運行主腳本無非就是用的模塊名稱導入更__main__。

• 有與沒有保存.pyc文件由於只讀目錄中的文件沒有問題; 蟒蛇簡單地忽略它，並在移動。

• 緩存腳本的好處是相同緩存任何模塊的：不浪費時間每次它的運行時間重新編譯腳本。 該文檔明確地承認這一點（「因此，腳本的啟動時間可能會減少......」）。

另一個問題需要注意：如果您運行python foo.py和foo.pyc存在，它不會被使用。你必須明確地說，python foo.pyc。 這是一個非常糟糕的主意：它意味著當它是不同步的Python不會自動重新編譯的.pyc文件的文件（由於.py文件變化），因此對.py文件的更改將不會使用，直到您手動重新編譯。 它也將與拋出一個RuntimeError徹底失敗如果升級的Python和.pyc文件的文件格式不再兼容，這經常發生。 通常情況下，這是所有透明地處理。

你不應該需要一個腳本移動到一個虛擬的模塊，並成立了引導腳本欺騙的Python到其高速緩存。 這是一個hackish的解決方法。

唯一可能（而且非常缺乏說服力）我之所以能湊合是避免從一堆pyc文件被雜亂的主目錄。 （這不是真正的理由;如果這是一個實際的問題，則pyc文件應保存為點文件）。這當然沒有理由不甚至有一個選項來做到這一點。

蟒絕對應該能夠緩存主模塊。

以來：

當它從.pyc文件或.pyo文件時，它是從一個.py文件閱讀不是閱讀程序不會跑得更快; 這是關於.pyc文件或.pyo文件的速度的唯一事情就是與它們載入速度。

這是不必要的，以產生用於主腳本pyc文件的文件。 只有那些可能會被載入多次圖書館應編制。

編輯：

這似乎你沒明白我的意思。 首先，認識到編制的整體思路.pyc文件也作出了同樣的文件在第二次執行速度更快。 然而，考慮是否做的Python編譯腳本正在運行。 解釋器將位元組碼寫入到一個.pyc的文件在第一次運行，這需要時間。 因此，它甚至會運行有點慢。 你可能會認為它會更快之後運行。 好吧，這只是一個選擇。 此外，作為this說：

明確優於隱式。

如果想通過使用加速.pyc的文件，應該手動編譯並運行.pyc明確文件。

要回答你的問題，參考6.1.3。 「編譯」Python文件在Python正式文件。

當腳本由命令行上給出它的名字運行，腳本的位元組碼不會被寫入一個.pyc文件或.pyo文件。 因此，腳本的啟動時間可通過移動它的大部分代碼的一個模塊，並具有導入這個模塊一小啟動腳本減少。 另外，也可以命名.pyc文件或直接.pyo文件的命令行上。

教育學

讓我又愛又恨類似這樣的問題上如此，因為有感情，意見的復雜混合物，和受過教育的猜測事情，人們開始變得snippy，不知何故每個人都失去了賽道的實際情況，最終失去了軌道原題的共。

這么多的技術問題都至少有一個明確的答案，但這些「為什麼」的問題往往沒有隻是一個單一的，確定的答案（例如，可以通過執行或引用權威人士的答案來驗證答案）。 在我看來，有兩個可能的方式來明確回答計算機科學「為什麼」的問題：

• 通過指向一個實現所關注的項目的源代碼。 這就解釋了「為什麼」從技術角度來看：什麼前提條件是必要的，以喚起這種行為？

• 通過指向人類可讀的文物（注釋，提交信息，郵件列表等）由參與作出該決定的開發人員編寫的。 這就是「為什麼」，我假設OP是感興趣的真正意義：為什麼Python的開發人員使這種看似隨意的決定？

第二種回答是更加難以證實，因為它需要獲得在誰寫的代碼開發者的心，特別是如果沒有容易找到，公開文件中的特定行為的決定。

迄今為止，這個討論有7回答是只專注於閱讀的Python的開發者的意圖，但只有一個在整批引用。 （它引用了不回答OP的問題了Python手冊的部分。）

這是我在與沿引用既回答了「為什麼」的問題兩側的嘗試。

源代碼

什麼是觸發.pyc文件編制的前提條件？ 讓我們來看看源代碼。 （煩人，在GitHub上Python沒有發布任何標記，所以我就告訴你，我在尋找715a6e）。

有在希望的代碼import.c:989在load_source_mole()函數。 我在這里切出一些位為簡潔起見。

static PyObject *
load_source_mole(char *name, char *pathname, FILE *fp)
{
// snip...

if (/* Can we read a .pyc file? */) {
/* Then use the .pyc file. */
}
else {
co = parse_source_mole(pathname, fp);
if (co == NULL)
return NULL;
if (Py_VerboseFlag)
PySys_WriteStderr("import %s # from %s ",
name, pathname);
if (cpathname) {
PyObject *ro = PySys_GetObject("dont_write_bytecode");
if (ro == NULL || !PyObject_IsTrue(ro))
write_compiled_mole(co, cpathname, &st);
}
}
m = PyImport_ExecCodeMoleEx(name, (PyObject *)co, pathname);
Py_DECREF(co);

return m;
}


pathname是路徑模塊和cpathname是相同的路徑，但是用pyc文件擴展名。 唯一的直接邏輯是布爾sys.dont_write_bytecode。 邏輯的其餘部分就是錯誤處理。 因此，我們所尋求的答案不在這里，但我們至少可以看到，調用此的任何代碼將導致在大多數默認配置的.pyc文件的文件。 該parse_source_mole()函數沒有真正意義要執行的流程，但我會在這里顯示，因為我會回來稍後。

static PyCodeObject *
parse_source_mole(const char *pathname, FILE *fp)
{
PyCodeObject *co = NULL;
mod_ty mod;
PyCompilerFlags flags;
PyArena *arena = PyArena_New();
if (arena == NULL)
return NULL;

flags.cf_flags = 0;

mod = PyParser_ASTFromFile(fp, pathname, Py_file_input, 0, 0, &flags,
NULL, arena);
if (mod) {
co = PyAST_Compile(mod, pathname, NULL, arena);
}
PyArena_Free(arena);
return co;
}


這里的顯著的方面是，函數解析和編譯的文件，並返回一個指針的位元組代碼（如果成功）。

現在，我們仍處於一個死胡同，讓我們處理這個從一個新的角度。 如何Python中載入它的參數，並執行它？ 在pythonrun.c有用於從文件載入代碼並執行它的幾個功能。PyRun_AnyFileExFlags()可以處理互動式和非互動式的文件描述符。 對於互動式的文件描述符，它委託給PyRun_InteractiveLoopFlags()這是REPL）和非互動式的文件描述符，它委託給PyRun_SimpleFileExFlags()PyRun_SimpleFileExFlags()檢查文件名 中結束.pyc。 如果這樣做的話，就調用run_pyc_file()直接載入編譯位元組碼從一個文件描述符然後運行它。

在更常見的情況下（即.py文件作為參數），PyRun_SimpleFileExFlags()調用PyRun_FileExFlags()這是我們開始找到了答案。

PyObject *
PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals,
PyObject *locals, int closeit, PyCompilerFlags *flags)
{
PyObject *ret;
mod_ty mod;
PyArena *arena = PyArena_New();
if (arena == NULL)
return NULL;

mod = PyParser_ASTFromFile(fp, filename, start, 0, 0,
flags, NULL, arena);
if (closeit)
fclose(fp);
if (mod == NULL) {
PyArena_Free(arena);
return NULL;
}
ret = run_mod(mod, filename, globals, locals, flags, arena);
PyArena_Free(arena);
return ret;
}

static PyObject *
run_mod(mod_ty mod, const char *filename, PyObject *globals, PyObject *locals,
PyCompilerFlags *flags, PyArena *arena)
{
PyCodeObject *co;
PyObject *v;
co = PyAST_Compile(mod, filename, flags, arena);
if (co == NULL)
return NULL;
v = PyEval_EvalCode(co, globals, locals);
Py_DECREF(co);
return v;
}


這里的突出的一點是，這兩個函數基本上執行相同的目的，進口商的load_source_mole()和parse_source_mole()它調用解析器創建從Python源代碼的AST，然後調用編譯器創建位元組碼。

那麼，這些代碼塊多餘的還是他們的目的不同？ 不同的是，一個塊載入從文件的模塊，而其他塊使用的是模塊作為參數。該模塊的說法是-在這種情況下-在__main__模塊，它使用的是低級別的C函數早些時候在初始化過程中創建的。 該__main__模塊不通過最正常的模塊導入代碼路徑，因為它是如此獨特，並且作為一個副作用，它不通過產生代碼去.pyc的文件。

總結：為什麼原因__main__。模塊未編譯.pyc文件是它是不是「進口」是的，它出現在sys.moles中，但它通過不是真正的模塊導入採取了非常不同的代碼路徑到達那裡。

開發者意圖

好了，我們現在可以看到的行為更多的是與Python的設計比在源代碼中任何明確表達的理由，但是這並沒有回答這是否是一種有意的決定，或只是一個副作用的問題這不打擾任何人足以成為值得改變。 一個開源的好處是，一旦我們發現我們感興趣的源代碼，我們可以使用VCS幫助追溯，導致目前實施的決定。

其中代碼的關鍵行這里（m = PyImport_AddMole("__main__");）的歷史可以追溯到1990年，並在自己BDFL，圭多寫的。 它已被修改，在干預的歲月，但修改是膚淺的。 當它第一次寫，一個腳本參數主模塊初始化是這樣的：

int
run_script(fp, filename)
FILE *fp;
char *filename;
{
object *m, *d, *v;
m = add_mole("`__main__`");
if (m == NULL)
return -1;
d = getmoledict(m);
v = run_file(fp, filename, file_input, d, d);
flushline();
if (v == NULL) {
print_error();
return -1;
}
DECREF(v);
return 0;
}


這之前存在.pyc的文件甚至被引入到Python的！ 難怪當時的設計沒有考慮匯編成賬戶腳本參數。 提交信息神秘地說：

「編譯」版本

這是幾十的一個承諾，在3天的時間......看來，圭多是深入到一些黑客/重構，這是一回到是穩定的第一個版本。 這種承諾甚至五年左右早於Python的開發郵件列表的創建！

保存編譯的位元組碼引入以後6個月，於1991年。

這仍然早於列表服務，所以我們有一個什麼樣圭多想沒有真正的想法。 看來，他只是認為，進口商為掛接到緩存位元組碼的目的，最好的地方。 他是否考慮做同樣為理念__main__不清：要麼沒有想到他，不然他認為這是更多的麻煩比它的價值。

我無法找到要緩存為主要模塊的位元組碼相關的bugs.python.org任何錯誤，也可以找到關於它的郵件列表上的任何消息，因此，顯然沒有人認為這是值得的麻煩嘗試添加它。

總結：為什麼所有模塊編譯的緣故.pyc除了__main__是，它是歷史的怪癖如何設計和實現。__main__被作品烤成代碼前.pyc的文件，即使存在。 如果你想知道的多的是，你需要電子郵件圭多和要求。

格倫·梅納德的回答說：

似乎沒有人想這樣說，但我敢肯定的答案很簡單：有這種行為沒有堅實的理由。

我同意100％。 有間接證據來支持這一理論，沒有人在這個線程別人提供的證據來支持任何其他理論的一個切絲。 我upvoted格倫的回答。

因為劇本正在運行可能會在某處是不恰當的生成pyc文件，如/usr/bin。

⑸ 安裝python模塊 是把哪個文件 考到哪裡 還要配置環境嗎

幾種情況

1. 預編譯好的exe文件，直接雙擊安裝即可

2. rar等包，解壓後，從命令行中cd到解壓的目錄，通過setup.py文件來安裝模塊：

   命令為，python setup.py install （若python未配置環境變數，則需要給python的安裝絕對路徑，如： C:/python27/python setup.py install）

備註：一般第三方模塊安裝好後，在 python安裝路徑/Lib/site-package下可以看得到

⑹ 後綴PY的文件怎麼用

後綴PY的文件可以用Python軟體打開，具體操作步驟如下：

1、首先確定一下我們要打開的PY文檔在哪裡。