python执行会预编译

Ⅰ 请教可以查看python解释器版本号或者安装路径命令

Python是解释型脚本语言，在执行时，逐句解释执行，不需要进行预编译。但需要有自身的Python解释器。
所以在执行Python代码时，需要指定python解释器。
指定解释器方法：
在文件开头添加搜索路径,
linux OS
中一般安装后的默认路径如下
#!/usr/bin/env python 或者#!/usr/locat/bin/python

如果没有找到，可以通过命令查询python路径
whereis python或者
which python

Windows OS
可以通过以下方式查询python路径或者第三方模块安装路径。
>>> import sys
>>> sys.path['C:\\Users\\zx\\Desktop', 'C:\\Users\\zx\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\site-packages']

cmd目录下运行python -V可查看python版本
修改默认python版本
先查看安装的python路径：
justin18chan@justin18chan:~$ whereis python
python: /usr/bin/python /usr/bin/python3.5 /usr/bin/python2.7-config /usr/bin/python3.5m /usr/bin/python2.7 /usr/lib/python3.5 /usr/lib/python2.7 /etc/python /etc/python3.5 /etc/python2.7 /usr/local/bin/python3.6m-config /usr/local/bin/python3.6-config /usr/local/bin/python3.6m /usr/local/bin/python3.6 /usr/local/lib/python3.5 /usr/local/lib/python3.6 /usr/local/lib/python2.7 /usr/include/python3.5m /usr/include/python2.7 /usr/share/python /usr/share/man/man1/python.1.gz

使用ln -s命令来修改，命令如下：
justin18chan@justin18chan:~$ sudo rm /usr/bin/python
[sudo] password for justin18chan: justin18chan@justin18chan:~$ sudo ln -s /usr/bin/python3.5 /usr/bin/python
justin18chan@justin18chan:~$ pythonPython 3.5.2 (default, Sep 14 2017, 22:51:06)

Ⅱ 为什么编译的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项目代码变更后一定要重新编译吗

一般的时候，你直接用py文件执行就可以了，python会自动编译一些必要的文件。
另外目前py不同的字节码是变动的，也就是说不同版本的字节码还是不兼容，做不动一次编译到处执行。
如果你现在三个文件 main.py, a.py, b.py
其中main是入口，而且在main中有import a.py 和import b.py
那么只会生成a.pyc,b.pyc，而不会生成main.pyc
出发你自己用python中的compile命令编译main.py
以上

Ⅳ python是什么样的编程语言

编程语言主要从以下几个角度为进行分类，编译型和解释型、静态语言和动态语言、强类型定义语言和弱类型定义语言，每个分类代表什么意思呢，我们一起来看一下。

2.1 编译型与解释型。

编译器是把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样运行时计算机可以直接以机器语言来运行此程序,速度很快;

而解释器则是只在执行程序时,才一条一条的解释成机器语言给计算机来执行,所以运行速度是不如编译后的程序运行的快的.

这是因为计算机不能直接认识并执行我们写的语句,它只能认识机器语言(是二进制的形式)

编译型

优点：编译器一般会有预编译的过程对代码进行优化。因为编译只做一次，运行时不需要编译，所以编译型语言的程序执行效率高。可以脱离语言环境独立运行。

缺点：编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运行环境生成机器码，不同的操作系统之间移植就会有问题，需要根据运行的操作系统环境编

解释型

优点：有良好的平台兼容性，在任何环境中都可以运行，前提是安装了解释器（虚拟机）。灵活，修改代码的时候直接修改就可以，可以快速部署，不用停机维护。

缺点：每次运行的时候都要解释一遍，性能上不如编译型语言。

2.2动态语言和静态语言

通常我们所说的动态语言、静态语言是指动态类型语言和静态类型语言。

（1）动态类型语言：动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，在用动态类型的语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来。Python和Ruby就是一种典型的动态类型语言，其他的各种脚本语言如VBScript也多少属于动态类型语言。

（2）静态类型语言：静态类型语言与动态类型语言刚好相反，它的数据类型是在编译其间检查的，也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，其他的静态类型语言还有C#、java等。

2.3强类型定义语言和弱类型定义语言

（1）强类型定义语言：强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。举个例子：如果你定义了一个整型变量a,那么程序根本不可能将a当作字符串类型处理。强类型定义语言是类型安全的语言。

（2）弱类型定义语言：数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。

强类型定义语言在速度上可能略逊色于弱类型定义语言，但是强类型定义语言带来的严谨性能够有效的避免许多错误。另外，"这门语言是不是动态语言”与"这门语言是否类型安全”之间是完全没有联系的！

例如：Python是动态语言，是强类型定义语言（类型安全的语言）; VBScript是动态语言，是弱类型定义语言（类型不安全的语言）; JAVA是静态语言，是强类型定义语言（类型安全的语言）。

通过上面这些介绍，我们可以得出，python是一门动态解释性的强类型定义语言。

Ⅳ Java，Python分别是解释型还是编译型语言

Java，Python都是解释型的，但是java会做一个语法检查的预编译，执行的时候才解释成机器语言。
C、C++才是编译型的
解释型的通用性好，可以跨平台
编译型的效率高。

Ⅵ python 有没有预编译文本

1.简介
相对于py文件来说，编译成pyc和pyo本质上和py没有太大区别，只是对于这个模块的加载速度提高了，并没有提高代码的执行速度，通常情况下不用主动去编译pyc文件，除非需要商业提供，防止源代码泄露。
（1）什么是pyc文件
pyc是一种二进制文件，是由py文件经过编译后，生成的文件，是一种byte code，py文件变成pyc文件后，加载的速度有所提高，而且pyc是一种跨平台的字节码，是由Python的虚拟机来执行的，这个是类似于Java虚拟机的概念。pyc的内容，是跟python的版本相关的，不同版本编译后的pyc文件是不同的，2.5编译的pyc文件，2.4版本的python是无法执行的。
（2）什么是pyo文件
pyo是优化编译后的程序 python -O 源文件即可将源程序编译为pyo文件
把需要的模块编译成pyo文件可以减少容量

2.反编译
将python文件编译为pyc文件（使用compileall 命令），再删除源代码。
(该文件类似于java中的class文件，但是我们使用的2.7版本的python，目前没有
免费版的反编译工具，所以目前要破解不是很容易，所以可以不必再做混淆)

（1）命令行编译方法：
python -m compileall src/
echo compile finished...
rm -rf src/*.py

编译成pyo的话:
就是在控制台执行 python -O -m py_compile file.py

（2）python程序编译方法：
如果需要特殊的单独编译，则只需要使用py_complie这个模块就行了，如下
import py_compile
py_compile.compile(r'H:\game\test.py')

反编译工具：
1.uncompyle2 只能编译2.7

反编译Demo代码：

import os
import sys

def displayFile(file):
unPath= sys.executable
unPath=unPath[ 0 : unPath.rfind( os.sep ) ]
newname = file[0:file.rfind('.')] + '.py'
command = "python -u "+unPath+"\scripts\uncompyle2 " + file + ">" + newname
try:
os.system(command)
except e:
print file

if __name__ == '__main__':

#print unPath
print 'init'
displayFile('E:\\test.pyc')
print 'finished'

2.zrax/pycdc 可以编译3.0

Ⅶ python代码运行需要编译吗

有人在讨论 Python 代码是编译执行还是解释执行？这个问题还可以换一种说法： Python 是编译型语言还是解释型语言？回答这个问题

前，我们先弄清楚什么是编译型语言，什么是解释型语言。

所谓编译执行就是源代码经过编译器编译处理，生成目标机器码，就是机器能直接运行的二进制代码，下次运行时无需重新编译。不过它

是针对特定CPU体系的，这些目标代码只能在特定平台执行，如果这个程序需要在另外一种 CPU 上面运行，这个代码就必须重新编译。

它不具备可移植性，但是执行速度快，C、C++这类语言属于编译型语言。

而解释型语言是在代码运行期间逐行翻译成目标机器码，下次执行时，还是需要逐行解释，我们可以简单认为 Java、Python 都是解释型

语言。

编译型相当于厨师直接做好一桌子菜，顾客来了直接开吃，而解释型就像吃火锅，厨师把菜洗好，顾客需要自己动手边煮边吃，效率上来

说解释型语言自然比不过编译型语言，当然也不是绝对了，像 JIT 的效率就很高

以上是对编译型语言和解释型语言的一个简单粗暴的区分，但是 Python（这里主要是指CPython）并不是严格的解释型语言，因为

Python 代码在运行前，会先编译（翻译）成中间代码，每个 .py 文件将被换转成 .pyc 文件，.pyc 就是一种字节码文件，它是与平台无

关的中间代码，不管你放在 Windows 还是 Linux 平台都可以执行，运行时将由虚拟机逐行把字节码翻译成目标代码。

我们安装Python 时候，会有一个 Python.exe 文件，它就是 Python 解释器，你写的每一行 Python 代码都是由它负责执行，解释器由

一个编译器和一个虚拟机构成，编译器负责将源代码转换成字节码文件，而虚拟机负责执行字节码，所以，解释型语言其实也有编译过

程，只不过这个编译过程并不是直接生成目标代码，而是中间代码（字节码），然后再通过虚拟机来逐行解释执行字节码。

总结

Python代码首先会编程一个字节码文件，再由虚拟机逐行解释，把每一行字节码代码翻译成目标指令给CPU执行。

推荐学习《Python教程》。

Ⅷ Python代码是编译执行还是解释执行

PYTHON是一种解释型的脚本语言，所以是解释执行的