blocks|key|3259694|text|CPU只能真正理解机器代码。对于解释程序，解释器的最终目标是将程序代码“解释”为机器代码。然而，现代的解释语言通常不会直接解释人类代码，因为它效率太低。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3259695|Python解释器首先读取人工代码并将其优化为某些中间代码，然后再将其解释为机器代码。这就是为什么您总是需要另一个程序来运行Python脚本，而在C%2B%2B中，您可以直接运行编译好的代码可执行文件。例如，c:\Python27\python.exe或/usr/bin/python。|offset|length|style|CODE|3259696|entityMap^0|0|2S|M|3F|F|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|I|$]]

The CPU can only understand machine code indeed. For interpreted programs, the ultimate goal of an interpreter is to "interpret" the program code into machine code. However, usually a modern interpreted language does not interpret human code directly because it is too inefficient.

The Python interpreter first reads the human code and optimizes it to some intermediate code before interpreting it into machine code. That's why you always need another program to run a Python script, unlike in C++ where you can run the compiled executable of your code directly. For example, <code>c:\Python27\python.exe</code> or <code>/usr/bin/python</code>.

blocks|key|2903099|text|首先，解释/编译不是语言的属性，而是实现的属性。对于大多数语言来说，大多数(如果不是全部的话)实现都属于一个类别，所以我们可能会节省几个单词，说明语言是被解释/编译的，但它仍然是一个重要的区别，这一方面是因为它有助于理解，另一方面是因为有相当多的语言具有两种可用的实现(主要是函数语言领域的语言，参见Haskell和ML)。此外，还有一些C解释器和项目试图将Python的子集编译为C或C%2B%2B代码(以及随后的机器代码)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2903100|第二，编译并不局限于提前编译到本机代码.编译器通常是将一种编程语言中的程序转换为另一种编程语言中的程序的程序(可以说，如果应用了重要的转换，甚至可以使用相同的输入和输出语言的编译器)。和JIT编译器在运行时编译为本机代码，这可以提供非常接近甚至优于提前编译的速度(取决于基准测试和比较实现的质量)。|2903101|但是，为了停止挑剔和回答您想问的问题:实际上(阅读:使用一个比较流行和成熟的实现)，Python是编译的。没有提前编译到机器代码(即受限制和错误的“编译”，但遗憾的是普通定义)，“只”编译到字节码，但它仍然具有一些好处。例如，语句a+=+b.c()被编译成一个字节流，当“分解”时，它看起来有点像load+0+(b);+load_str+'c';+get_attr;+call_function+0;+store+1+(a)。这是一种简化，实际上它的可读性更低一些--你可以用标准库模块进行实验，看看真正的交易是什么样子。解释这个比从更高层次的表示法解释要快。|offset|length|style|BOLD|CODE|2903102|该字节码要么被解释(请注意，在理论和实际性能上，直接解释和第一次编译到某种中间表示并对其进行解释是有区别的)，比如引用实现(CPython)，或者在运行时解释和编译到优化的机器代码，比如PyPy。|2903103|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Bytecode|1|http://docs.python.org/library/dis.html|2|http://pypy.org/^0|0|0|1D|3|37|9|44|1S|2N|3|0|6P|2|1|0|2L|4|2|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@$F|11|G|12|H|I]|$F|13|G|14|H|J]|$F|15|G|16|H|J]]|9|@$F|17|G|18|1|19]|$F|1A|G|1B|1|1C]]|A|$]]|$1|K|3|L|5|6|7|1D|8|@]|9|@$F|1E|G|1F|1|1G]]|A|$]]|$1|M|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]|U|$5|P|Q|R|A|$S|V]]|W|$5|P|Q|R|A|$S|X]]]]

First off, interpreted/compiled is not a property of the language but a property of the implementation. For most languages, most if not all implementations fall in one category, so one might save a few words saying the language is interpreted/compiled too, but it's still an important distinction, both because it aids understanding and because there are quite a few languages with usable implementations of both kinds (mostly in the realm of functional languages, see Haskell and ML). In addition, there are C interpreters and projects that attempt to compile a subset of Python to C or C++ code (and subsequently to machine code).

Second, compilation is not restricted to ahead-of-time compilation to native machine code. A compiler is, more generally, a program that converts a program in one programming language into a program in another programming language (arguably, you can even have a compiler with the same input and output language if significant transformations are applied). And JIT compilers compile to native machine code at runtime, which can give speed very close to or even better than ahead of time compilation (depending on the benchmark and the quality of the implementations compared).

But to stop nitpicking and answer the question you meant to ask: Practically (read: using a somewhat popular and mature implementation), Python is compiled. Not compiled to machine code ahead of time (i.e. "compiled" by the restricted and wrong, but alas common definition), "only" compiled to <a href="http://en.wikipedia.org/wiki/Bytecode" rel="noreferrer">bytecode</a>, but it's still compilation with at least some of the benefits. For example, the statement <code>a = b.c()</code> is compiled to a byte stream which, when "disassembled", looks somewhat like <code>load 0 (b); load_str 'c'; get_attr; call_function 0; store 1 (a)</code>. This is a simplification, it's actually less readable and a bit more low-level - you can experiment with the standard library <a href="http://docs.python.org/library/dis.html" rel="noreferrer"><code>dis</code> module</a> and see what the real deal looks like. Interpreting this is faster than interpreting from a higher-level representation.

That bytecode is either interpreted (note that there's a difference, both in theory and in practical performance, between interpreting directly and first compiling to some intermediate representation and interpret that), as with the reference implementation (CPython), or both interpreted and compiled to optimized machine code at runtime, as with <a href="http://pypy.org/" rel="noreferrer">PyPy</a>.

blocks|key|3259786|text|几乎可以说，Python是一种解释语言。但是我们在python中使用了一次编译过程中的某些部分来将完整的源代码转换成像java语言这样的字节代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3259787|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Almost, we can say Python is interpreted language. But we are using some part of one time compilation process in python to convert complete source code into byte-code like java language.

blocks|key|2903149|text|答案取决于所使用的python的实现。如果您使用的是CPython+(+python的标准实现)或Jython+(用于与java编程语言集成)，则首先将其转换为字节码，并根据您使用的python的实现，将此字节码定向到相应的虚拟机以进行解释。+(Python+)用于CPython，(+Jython+)用于Jython。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2903150|但是，假设您使用的是PyPy，这是另一个标准的CPython实现。它将使用即时编译器。|2903151|entityMap^0|Q|7|1D|6|28|3|2V|H|0|A|4|11|5|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|I|$]]

The answer depends on what implementation of python is being used. If you are using lets say CPython (The Standard implementation of python) or Jython (Targeted for integration with java programming language)it is first translated into bytecode, and depending on the implementation of python you are using, this bycode is directed to the corresponding virtual machine for interpretation. PVM (Python Virtual Machine) for CPython and JVM (Java Virtual Machine) for Jython.

But lets say you are using PyPy which is another standard CPython implementation. It would use a Just-In-Time Compiler.

blocks|key|3259836|text|根据官方的Python站点，它是被解释的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3259837|https://www.python.org/doc/essays/blurb/|offset|length|3259838|Python是一种解释的、面向对象的高级编程语言.|blockquote|3259839|..。|3259840|因为没有编译步骤..。|3259841|3259842|Python解释器和广泛的标准库是可用的。|3259843|3259844|相反，当解释器发现错误时，会引发异常。当程序没有捕获异常时，解释器将打印堆栈跟踪。|3259845|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|14|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@$D|11|E|12|1|13]]|A|$]]|$1|F|3|G|5|H|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|H|7|16|8|@]|9|@]|A|$]]|$1|M|3|J|5|6|7|17|8|@]|9|@]|A|$]]|$1|N|3|O|5|H|7|18|8|@]|9|@]|A|$]]|$1|P|3|J|5|6|7|19|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|1A|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|C]]]]

According to the official Python site, it's interpreted.
<a href="https://www.python.org/doc/essays/blurb/" rel="noreferrer">https://www.python.org/doc/essays/blurb/</a>
<blockquote>
Python is an interpreted, object-oriented, high-level programming language...
</blockquote>
...
<blockquote>
Since there is no compilation step ...
</blockquote>
...
<blockquote>
The Python interpreter and the extensive standard library are available...
</blockquote>
...
<blockquote>
Instead, when the interpreter discovers an error, it raises an
exception. When the program doesn't catch the exception, the
interpreter prints a stack trace.
</blockquote>

blocks|key|3259889|text|您编写的python代码被编译成python，该字节码创建扩展名为.pyc的文件。如果编译，同样的问题是，为什么不编译语言。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3259890|注意，这不是传统意义上的汇编。通常，我们会说编译是采用高级语言并将其转换为机器代码。但这是某种形式的汇编。编译成中间代码，而不是机器代码(希望你现在得到了)。|3259891|回到执行过程，在编译步骤中创建的字节码由适当的虚拟机执行，在我们的示例中，CPython+VM使用时间戳(称为神奇号)来验证是否更改了.py文件，这取决于是否创建了新的.py文件。如果pyc是当前代码的，那么它只是跳过编译步骤。|3259892|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The python code you write is compiled into python bytecode, which creates file with extension .pyc. If compiles, again question is, why not compiled language. 

Note that this isn't compilation in the traditional sense of the word. Typically, we’d say that compilation is taking a high-level language and converting it to machine code. But it is a compilation of sorts. Compiled in to intermediate code not into machine code (Hope you got it Now).

Back to the execution process, your bytecode, present in pyc file, created in compilation step, is then executed by appropriate virtual machines, in our case, the CPython VM 
The time-stamp (called as magic number) is used to validate whether .py file is changed or not, depending on that new pyc file is created. If pyc is of current code then it simply skips compilation step.

blocks|key|2903232|text|如果(你知道Java+)+{|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2903233|Python代码和java一样被转换成字节码。|2903234|每次尝试访问字节码时，都会再次执行该字节码。|2903235|}+{|2903236|Python代码最初被转换成所谓的字节码。|2903237|这与机器语言非常接近，但并不是实际的机器代码。|2903238|因此，每次我们访问或运行字节码时，都会再次执行字节码。|2903239|}|2903240|entityMap^0|0|E|0|0|0|0|3|0|0|0|0|0|1|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|13|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|14|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|15|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|T|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|U|$]]

If ( You know Java ) { 
Python code is converted into bytecode like java does. 
That bytecode is executed again everytime you try to access it. 
} else { 
Python code is initially traslated into something called bytecode that is quite 
close to machine language but not actual machine code 
so each time we access or run it that bytecode is executed again 
}

blocks|key|1706515|text|是的，它既是编译语言，也是解释语言。，那么为什么我们通常把它称为解释语言呢？|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1706516|查看它是如何编译和解释的？|1706517|首先，我想告诉你，如果你来自Java世界，你会更喜欢我的答案。|1706518|在Java中，源代码首先通过javac编译器转换为字节代码，然后定向到，以生成用于执行的本机代码)。现在，我想向您展示，我们将Java称为编译语言，因为我们可以看到它确实编译了源代码，并通过以下方式给出了.class文件(只有字节码)：|1706519|javac+Hello.java+->生成Hello.class文件。|1706520|java+Hello|1706521|在python中也会发生同样的事情，即首先通过编译器将源代码转换为字节码，然后定向到PVM(responsible以生成用于执行的本机代码)。现在，我想向您展示，我们通常将Python称为一种解释语言，因为编译发生在场景后面，当我们运行python代码时：|1706522|python+Hello.py|1706523|@+python+Hello.py看起来是直接执行的，但实际上它首先生成由解释器解释的字节码，以生成用于执行目的的本机代码。|1706524|CPython-+-负责编译和解释。|1706525|如果您需要更详细的，请查看下面的行|1706526|正如我所提到的，CPython编译源代码，但是实际编译是在cython的帮助下进行的，然后在CPython的帮助下进行解释。|1706527|现在让我们来谈谈和Python中实时编译器的作用。|1706528|在JVM中，Java解释器存在逐行解释字节码以获得用于执行的本机代码，但当Java字节码由解释器执行时，执行速度总是较慢。那么解决方案是什么呢？解决方案是实时编译器，它生成本机代码，其执行速度比解释要快得多。一些JVM供应商使用Java解释器，而有些使用即时编译器.参考资料：单击此处|1706529|在python中，为了绕过解释器来实现快速执行，使用另一个python+implementation(PyPy)而不是CPython。单击此处用于python的其他实现，包括PyPy。|1706530|entityMap|0|LINK|mutability|MUTABLE|url|http://cython.org/|1|https://en.wikipedia.org/wiki/Java_virtual_machine#Bytecode_interpreter_and_just-in-time_compiler|2|https://docs.python.org/3/reference/introduction.html?highlight=cpython#alternate-implementations^0|0|12|0|0|D|0|0|E|5|Z|2B|0|0|Z|0|0|A|0|0|3K|0|0|6|7|8|0|0|1Q|0|0|I|0|0|H|0|0|1Q|T|6|0|0|0|P|0|0|3Y|3U|4|1|0|0|2K|1V|4|2|0^^$0|@$1|2|3|4|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1M|8|@$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1P|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1Q|8|@$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|1V|8|@$9|1W|A|1X|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|1Y|8|@$9|1Z|A|20|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|21|8|@$9|22|A|23|B|C]]|D|@]|E|$]]|$1|R|3|S|5|6|7|24|8|@$9|25|A|26|B|C]|$9|27|A|28|B|C]]|D|@]|E|$]]|$1|T|3|U|5|6|7|29|8|@$9|2A|A|2B|B|C]]|D|@]|E|$]]|$1|V|3|W|5|6|7|2C|8|@$9|2D|A|2E|B|C]]|D|@]|E|$]]|$1|X|3|Y|5|6|7|2F|8|@$9|2G|A|2H|B|C]]|D|@]|E|$]]|$1|Z|3|10|5|6|7|2I|8|@$9|2J|A|2K|B|C]]|D|@$9|2L|A|2M|1|2N]]|E|$]]|$1|11|3|12|5|6|7|2O|8|@$9|2P|A|2Q|B|C]]|D|@]|E|$]]|$1|13|3|14|5|6|7|2R|8|@$9|2S|A|2T|B|C]]|D|@$9|2U|A|2V|1|2W]]|E|$]]|$1|15|3|16|5|6|7|2X|8|@$9|2Y|A|2Z|B|C]]|D|@$9|30|A|31|1|32]]|E|$]]|$1|17|3|-4|5|6|7|33|8|@]|D|@]|E|$]]]|18|$19|$5|1A|1B|1C|E|$1D|1E]]|1F|$5|1A|1B|1C|E|$1D|1G]]|1H|$5|1A|1B|1C|E|$1D|1I]]]]

Yes, it is both compiled and interpreted language. Then why we generally call it as interpreted language?

see how it is both- compiled and interpreted?

First of all I want to tell that you will like my answer more if you are from the Java world.

In the Java the source code first gets converted to the byte code through javac compiler then directed to the JVM(responsible for generating the native code for execution purpose). Now I want to show you that we call the Java as compiled language because we can see that it really compiles the source code and gives the .class file(nothing but bytecode) through:

javac Hello.java -------> produces Hello.class file

java Hello -------->Directing bytecode to JVM for execution purpose

The same thing happens with python i.e. first the source code gets converted to the bytecode through the compiler then directed to the PVM(responsible for generating the native code for execution purpose). Now I want to show you that we usually call the Python as an interpreted language because the compilation happens behind the scene
and when we run the python code through: 

python Hello.py -------> directly excutes the code and we can see the output provied that code is syntactically correct

@ python Hello.py it looks like it directly executes but really it first generates the bytecode that is interpreted by the interpreter to produce the native code for the execution purpose.

CPython- Takes the responsibility of both compilation and interpretation.

Look into the below lines if you need more detail:

As I mentioned that CPython compiles the source code but actual compilation happens with the help of <a href="http://cython.org/" rel="noreferrer">cython</a> then interpretation happens with the help of CPython

Now let's talk a little bit about the role of Just-In-Time compiler in Java and Python

In JVM the Java Interpreter exists which interprets the bytecode line by line to get the native machine code for execution purpose but when Java bytecode is executed by an interpreter, the execution will always be slower. So what is the solution? the solution is Just-In-Time compiler which produces the native code which can be executed much more quickly than that could be interpreted. Some JVM vendors use Java Interpreter and some use Just-In-Time compiler. Reference: <a href="https://en.wikipedia.org/wiki/Java_virtual_machine#Bytecode_interpreter_and_just-in-time_compiler" rel="noreferrer">click here</a>

In python to get around the interpreter to achieve the fast execution use another python implementation(PyPy) instead of CPython.
<a href="https://docs.python.org/3/reference/introduction.html?highlight=cpython#alternate-implementations" rel="noreferrer">click here</a> for other implementation of python including PyPy.

blocks|key|3259989|text|For+newbies|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3259990|Python在运行脚本之前会自动将脚本编译成已编译的代码，即所谓的字节代码。|3259991|运行脚本不被视为导入，也不会创建.pyc。|3259992|例如，如果您有一个导入另一个模块xyz.py的脚本文件xyz.py，那么当您运行abc.py时，将创建自xyz导入的xyz.pyc，但由于未导入abc.py，因此不会创建abc.pyc文件。|3259993|entityMap^0|0|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|S|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|M|$]]

For newbies

Python automatically compiles your script to compiled code, so called byte code, before running it.

Running a script is not considered an import and no .pyc will be created.

For example, if you have a script file abc.py that imports another module xyz.py, when you run abc.py, xyz.pyc will be created since xyz is imported, but no abc.pyc file will be created since abc.py isn’t being imported.

blocks|key|3260029|text|Python(解释器)是编译的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3260030|证明:如果包含语法错误，那么它甚至不会编译代码。|3260031|示例1：|3260032|print("This+should+print")+
a+=+9/0+|code-block|syntax|javascript|3260033|输出：|3260034|This+should+print
Traceback+(most+recent+call+last):
++File+"p.py",+line+2,+in+<module>
++++a+=+9/0
ZeroDivisionError:+integer+division+or+modulo+by+zero|3260035|成功编译代码。第一行执行(print)第二行抛出ZeroDivisionError+(运行时错误)。|blockquote|CODE|3260036|示例2：|3260037|print("This+should+not+print")
/0+++++++++|3260038|3260039|++File+"p.py",+line+2
++++/0
++++%5E
SyntaxError:+invalid+syntax|3260040|SyntaxError结论:如果您的代码文件包含，那么编译失败时不会执行任何操作。|3260041|entityMap^0|C|3|0|5|J|0|0|4|0|0|0|3|0|0|0|1E|D|5|O|H|0|0|4|0|0|0|3|0|0|0|15|0|B|0^^$0|@$1|2|3|4|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|1G|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1K|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|U|7|1L|8|@$9|1M|A|1N|B|C]|$9|1O|A|1P|B|V]|$9|1Q|A|1R|B|V]]|D|@]|E|$]]|$1|W|3|X|5|6|7|1S|8|@$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|L|7|1V|8|@]|D|@]|E|$M|N]]|$1|10|3|P|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|11|3|12|5|L|7|1Z|8|@]|D|@]|E|$M|N]]|$1|13|3|14|5|U|7|20|8|@$9|21|A|22|B|C]|$9|23|A|24|B|V]]|D|@]|E|$]]|$1|15|3|-4|5|6|7|25|8|@]|D|@]|E|$]]]|16|$]]

Python(the interpreter) is compiled. 

Proof: It won't even compile your code if it contains syntax error. 

Example 1: 

<pre><code>print("This should print") 
a = 9/0 
</code></pre>

Output:

<pre><code>This should print
Traceback (most recent call last):
 File "p.py", line 2, in &lt;module&gt;
 a = 9/0
ZeroDivisionError: integer division or modulo by zero
</code></pre>

<blockquote>
 Code gets compiled successfully. First line gets executed (<code>print</code>) second line throws <code>ZeroDivisionError</code> (run time error) .
</blockquote>

Example 2: 

<pre><code>print("This should not print")
/0 
</code></pre>

Output: 

<pre><code> File "p.py", line 2
 /0
 ^
SyntaxError: invalid syntax
</code></pre>

<blockquote>
 Conclusion: If your code file contains <code>SyntaxError</code> nothing will execute as compilation fails.
</blockquote>

blocks|key|3260139|text|对于刚开始研究python的人来说，这是一个很大的混乱，这里的答案有点难以理解，所以我会让它更容易理解。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3260140|当我们指示Python运行我们的脚本时，Python在代码真正开始运行之前执行了几个步骤：|3260141|它被编译成字节码。|unordered-list-item|3260142|然后将其路由到虚拟机。|3260143|当我们执行一些源代码时，Python会将其编译成字节代码。编译是一个转换步骤，字节码是一个独立于平台的底层源代码表示.|3260144|注意，Python字节码不是二进制机器代码(例如，Intel芯片的指令)。|3260145|实际上，Python将源代码的每条语句分解为各个步骤，从而将它们转换为字节代码指令。执行字节码转换以加快执行速度。字节码可以比原始源代码语句运行得快得多。它是has.pyc扩展，如果它可以写到我们的机器上，它就会被写入。|3260146|因此，下次我们运行相同的程序时，Python将加载.pyc文件并跳过编译步骤，除非它已经更改。Python自动检查源代码和字节代码文件的时间戳，以了解何时必须重新编译。如果我们重新保存源代码，下一次运行程序时，将自动创建字节码。|3260147|如果Python不能将字节码文件写入我们的机器，我们的程序仍然可以工作。字节码在内存中生成，在程序退出时被丢弃。但是，由于.pyc文件的启动时间较快，我们可能需要确保它是为较大的程序编写的。|3260148|让我们总结一下幕后发生的事情。执行程序时，Python将.py读入内存，并进行解析以获得字节码，然后继续执行。对于程序导入的每个模块，Python首先检查是否有预编译的字节码版本(在.pyo或.pyc中)是否有与其.py文件对应的时间戳。Python使用字节码版本(如果有的话)。否则，它将解析模块的.py文件，将其保存到.pyc文件中，并使用刚刚创建的字节码。|offset|length|style|BOLD|3260149|字节码文件也是传送Python代码的一种方式。如果能够找到are.pyc文件，即使原始.py源文件不存在，Python仍然会运行程序。|3260150|Python虚拟机(PVM)|3260151|一旦我们的程序被编译成字节码，它就会被发送到Python虚拟机(PVM)执行。PVM不是一个单独的程序。它不需要自己安装。实际上，PVM只是一个很大的循环，它一个接一个地遍历我们的字节码指令来执行它们的操作。PVM是Python的运行时引擎。它总是作为Python系统的一部分出现。它是真正运行我们的脚本的组件。从技术上讲，这只是Python解释器的最后一步。|3260152|entityMap^0|0|0|0|0|0|0|0|0|0|0|F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|18|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|19|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1A|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1B|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1C|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1D|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1E|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1F|8|@$U|1G|V|1H|W|X]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1I|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1J|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1K|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|15|$]]

Its a big confusion for people who just started working in python and the answers here are a little difficult to comprehend so i'll make it easier.
When we instruct Python to run our script, there are a few steps that Python carries out before our code actually starts crunching away:
<ul>
<li>It is compiled to bytecode.</li>
<li>Then it is routed to virtual machine.</li>
</ul>
When we execute some source code, Python compiles it into byte code. Compilation is a translation step, and the byte code is a low-level platform-independent representation of source code.
Note that the Python byte code is not binary machine code (e.g., instructions for an Intel chip).
Actually, Python translate each statement of the source code into byte code instructions by decomposing them into individual steps. The byte code translation is performed to speed execution.
Byte code can be run much more quickly than the original source code statements. It has.pyc extension and it will be written if it can write to our machine.
So, next time we run the same program, Python will load the .pyc file and skip the compilation step unless it's been changed. Python automatically checks the timestamps of source and byte code files to know when it must recompile. If we resave the source code, byte code is automatically created again the next time the program is run.
If Python cannot write the byte code files to our machine, our program still works. The byte code is generated in memory and simply discarded on program exit. But because .pyc files speed startup time, we may want to make sure it has been written for larger programs.
Let's summarize what happens behind the scenes.
When Python executes a program, Python reads the .py into memory, and parses it in order to get a bytecode, then goes on to execute. For each module that is imported by the program, Python first checks to see whether there is a precompiled bytecode version, in a .pyo or .pyc, that has a timestamp which corresponds to its .py file. Python uses the bytecode version if any. Otherwise, it parses the module's .py file, saves it into a .pyc file, and uses the bytecode it just created.
Byte code files are also one way of shipping Python codes. Python will still run a program if all it can find are.pyc files, even if the original .py source files are not there.
Python Virtual Machine (PVM)
Once our program has been compiled into byte code, it is shipped off for execution to Python Virtual Machine (PVM). The PVM is not a separate program. It need not be installed by itself. Actually, the PVM is just a big loop that iterates through our byte code instruction, one by one, to carry out their operations. The PVM is the runtime engine of Python. It's always present as part of the Python system. It's the component that truly runs our scripts. Technically it's just the last step of what is called the Python interpreter.

blocks|key|2903418|text|在我看来，Python被放入解释器categoty中，因为它的设计能够完全处理单个python语句(从python代码到cpu中的执行)。也就是说，您编写一条语句，可以执行它，如果没有错误，则得到相应的结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2903419|有一个中间代码(比如字节码)，我相信把它归类为编译器并没有什么区别。虽然这个组件(中间代码生成)通常是编译器的一部分，但是它也可以在解释器中使用。请参见解释器(计算)的wiki定义。提高执行速度是提高效率的关键。由于缓存功能更强大，所以如果在当前的程序范围内没有修改代码，就可以跳过大量的处理步骤，比如词法、语义分析，甚至一些代码优化。|offset|length|2903420|entityMap|0|LINK|mutability|MUTABLE|url|https://en.m.wikipedia.org/wiki/Interpreter_(computing))^0|0|27|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

In my opinion Python is put into an interpreter categoty because its designed to be capable of fully processing ( from python code to execution in cpu) individual python statement. I.e. you write one statement and you can execute it and if no errors then get the corresponding result.
Having an intermediate code (like bytecode) i believe doesnt make difference to categorize it overall as compiler. Though this component (intermediate code generation) is typically been part of compiler but it can also be used in interpreters. See wiki definition of interpreter <a href="https://en.m.wikipedia.org/wiki/Interpreter_(computing)" rel="nofollow noreferrer">https://en.m.wikipedia.org/wiki/Interpreter_(computing)</a>. Its a crucial piece to add efficiency in terms of execution speed. With cache its even more powerful so that if you havent changed code in current program scope you skip heavy processing steps like lexical, semantic analysis and even some of code optimization.

blocks|key|2903432|text|正如有人已经说过的，“解释/编译不是语言的属性，而是实现的属性。”Python既可以用于解释模式，也可以用于编译模式。当您直接从终端或cmd运行python代码时，python解释器就会启动。现在，如果您编写任何命令，则将直接解释该命令。如果您使用包含Python代码的文件并在IDE中运行它，或者使用命令提示符，它将首先编译，整个代码将转换为字节代码，然后运行。所以这取决于我们如何使用它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2903433|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

As sone one already said, &quot;interpreted/compiled is not a property of the language but a property of the implementation.&quot; Python can be used in interpretation mode as well as compilation mode. When you run python code directly from terminal or cmd then the python interpreter starts. Now if you write any command then this command will be directly interpreted. If you use a file containing Python code and running it in IDE or using a command prompt it will be compiled first the whole code will be converted to byte code and then it will run. So it depends on how we use it.

blocks|key|2903480|text|似乎是语义学的例子。我认为我们大多数人推断编译的通常结果是机器代码。考虑到这一点，我对自己说，python是不编译的。但是我错了，因为编译实际上意味着转换到更低的级别，所以从源代码到字节代码的转换也在编译中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2903481|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Seems to be a case of semantics. I think most of us infer that the usual result of compiling is machine-code. With that in mind I say to myself that python is not compiled. I would be wrong though because compile really means convert to a lower level so converting from source to byte-code is also compiling.

From my understanding:

An interpreted language is a high-level language run and executed by an interpreter (a program which converts the high-level language to machine code and then executing) on the go; it processes the program a little at a time.

A compiled language is a high-level language whose code is first converted to machine-code by a compiler (a program which converts the high-level language to machine code) and then executed by an executor (another program for running the code).

Correct me if my definitions are wrong.

Now coming back to Python, I am bit confused about this. Everywhere you learn that Python is an interpreted language, but it's interpreted to some intermediate code (like byte-code or IL) and not to the machine code. So which program then executes the IM code? Please help me understand how a Python script is handled and run.

Is Python interpreted, or compiled, or both?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

据我理解：解释的语言是一种高级语言，由解释器(一个将高级语言转换为机器代码然后执行的程序)运行和执行；它一次只处理一些程序。编译的语言是一种高级语言，其代码首先由编译器(将高级语言转换为机器代码的程序)转换为机器代码，然后由执行器(运行代码的另一个程序)执行。如果我的定义是错误的，请纠正我。现在回到Python，我对此...

问Python是被解释或编译的，还是两者兼而有之？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python是被解释或编译的，还是两者兼而有之？EN