术语解释器是一个遗留术语，可以追溯到早期的shell脚本语言。由于“脚本语言”已经演变成功能齐全的语言，它们对应的平台也变得更加复杂和沙箱化，虚拟机和解释器(在Python意义上)之间的区别非常小，甚至不存在。

Python解释器仍然以与shell脚本相同的方式运行，从某种意义上说，它可以在不需要单独的编译步骤的情况下执行。除此之外，Python解释器(或Perl或Ruby的)和Java虚拟机之间的区别主要是实现细节。(有人可能会说Java比Python更加完全沙箱化，但两者最终都通过原生C接口提供对底层架构的访问。)

术语不同的一个原因可能是，人们通常认为向python解释器提供人类可读的原始源代码，而不用担心字节码之类的问题。

在Java中，必须显式地编译为字节码，然后在VM上只运行字节码，而不是源代码。

尽管Python在幕后使用虚拟机，但从用户的角度来看，大多数时候可以忽略这个细节。

for posts that mention that python does not need to generate byte code, I'm not sure that's true. it seems that all callables in Python must have a .__code__.co_code attribute which contains the byte code. I don't see a meaningful reason to call python "not compiled" just because the compiled artifacts may not be saved; and often aren't saved by design in Python, for example all comprehension compile new bytecode for it's input, this is the reason comprehension variable scope is not consistent between compile(mode='exec, ...) and compile compile(mode='single', ...) such as between running a python script and using pdb

他们之间没有真正的区别，人们只是遵循创造者选择的惯例。

我认为两者之间的界限是模糊的，人们大多争论的是“解释器”这个词的含义，以及语言与“解释器……编译器”范围的每一方有多接近。然而，没有一个是100%的。我认为编写Java或Python实现是很容易的，这是频谱的任何价值。

目前Java和Python都有虚拟机和字节码，尽管一个操作具体的值大小(如32位整数)，而另一个必须确定每次调用的大小，在我看来，这并没有定义术语之间的边界。

Python没有正式定义的字节码，它只存在于内存中，这一论点也不能说服我，只是因为我计划开发只识别Python字节码的设备，编译部分将在浏览器JS机器中完成。

性能只与具体的实现有关。我们不需要知道对象的大小就能处理它，最后，在大多数情况下，我们处理的是结构，而不是基本类型。可以通过重用现有对象来优化Python VM，从而消除每次在表达式计算期间创建新对象的需要。一旦完成，在计算两个整数的和之间没有全局性能差异，这是Java的闪光点。

两者之间没有致命的区别，只有一些与最终用户无关的实现上的细微差别和缺乏优化，可能在她开始注意到性能滞后的时候，但这又是实现而不是架构的问题。

在本文中，“虚拟机”指的是进程虚拟机，不是指 系统虚拟机，如Qemu或Virtualbox。进程虚拟机为 一个简单的程序，它提供了一个通用的编程环境——程序 这是可以编程的。

Java has an interpreter as well as a virtual machine, and Python has a virtual machine as well as an interpreter. The reason "virtual machine" is a more common term in Java and "interpreter" is a more common term in Python has a lot to do with the major difference between the two languages: static typing (Java) vs dynamic typing (Python). In this context, "type" refers to primitive data types -- types which suggest the in-memory storage size of the data. The Java virtual machine has it easy. It requires the programmer to specify the primitive data type of each variable. This provides sufficient information for Java bytecode not only to be interpreted and executed by the Java virtual machine, but even to be compiled into machine instructions. The Python virtual machine is more complex in the sense that it takes on the additional task of pausing before the execution of each operation to determine the primitive data types for each variable or data structure involved in the operation. Python frees the programmer from thinking in terms of primitive data types, and allows operations to be expressed at a higher level. The price of this freedom is performance. "Interpreter" is the preferred term for Python because it has to pause to inspect data types, and also because the comparatively concise syntax of dynamically-typed languages is a good fit for interactive interfaces. There's no technical barrier to building an interactive Java interface, but trying to write any statically-typed code interactively would be tedious, so it just isn't done that way.

在Java世界中，虚拟机最引人注目，因为它运行程序 用一种可以编译成机器指令的语言编写， 结果就是速度和资源效率。可以执行Java字节码 通过Java虚拟机，性能接近编译 程序，相对来说。这是由于原始数据的存在 在字节码中键入信息。Java虚拟机将Java放在 自身类别:

可移植的解释静态类型语言

仅次于LLVM的是LLVM，但LLVM在不同的级别上运行:

可移植解释汇编语言

The term "bytecode" is used in both Java and Python, but not all bytecode is created equal. bytecode is just the generic term for intermediate languages used by compilers/interpreters. Even C compilers like gcc use an intermediate language (or several) to get the job done. Java bytecode contains information about primitive data types, whereas Python bytecode does not. In this respect, the Python (and Bash,Perl,Ruby, etc.) virtual machine truly is fundamentally slower than the Java virtual machine, or rather, it simply has more work to do. It is useful to consider what information is contained in different bytecode formats:

Llvm: CPU寄存器 原始数据类型 Python:用户定义类型

做一个现实世界的类比:LLVM使用原子，即Java虚拟机 Python虚拟机处理的是材料。 因为所有东西最终都必须分解成亚原子粒子(真实的 机器操作)，Python虚拟机有最复杂的任务。

Intepreters/compilers of statically-typed languages just don't have the same baggage that interpreters/compilers of dynamically-typed languages have. Programmers of statically-typed languages have to take up the slack, for which the payoff is performance. However, just as all nondeterministic functions are secretly deterministic, so are all dynamically-typed languages secretly statically-typed. Performance differences between the two language families should therefore level out around the time Python changes its name to HAL 9000.

The virtual machines of dynamic languages like Python implement some idealized logical machine, and don't necessarily correspond very closely to any real physical hardware. The Java virtual machine, in contrast, is more similar in functionality to a classical C compiler, except that instead of emitting machine instructions, it executes built-in routines. In Python, an integer is a Python object with a bunch of attributes and methods attached to it. In Java, an int is a designated number of bits, usually 32. It's not really a fair comparison. Python integers should really be compared to the Java Integer class. Java's "int" primitive data type can't be compared to anything in the Python language, because the Python language simply lacks this layer of primitives, and so does Python bytecode.

因为Java变量是显式类型的，所以可以合理地期望 比如Jython的性能在同一范围内 cPython的。另一方面，一个用Python实现的Java虚拟机 肯定比泥的速度要慢。不要指望Ruby, Perl等等， 为了更好的生活。它们的设计初衷不是这样的。它们是为 “脚本”，这是动态语言编程的称呼。

Every operation that takes place in a virtual machine eventually has to hit real hardware. Virtual machines contain pre-compiled routines which are general enough to to execute any combination of logical operations. A virtual machine may not be emitting new machine instructions, but it certainly is executing its own routines over and over in arbirtrarily complex sequences. The Java virtual machine, the Python virtual machine, and all the other general-purpose virtual machines out there are equal in the sense that they can be coaxed into performing any logic you can dream up, but they are different in terms of what tasks they take on, and what tasks they leave to the programmer.

Psyco for Python is not a full Python virtual machine, but a just-in-time compiler that hijacks the regular Python virtual machine at points it thinks it can compile a few lines of code -- mainly loops where it thinks the primitive type of some variable will remain constant even if the value is changing with each iteration. In that case, it can forego some of the incessent type determination of the regular virtual machine. You have to be a little careful, though, lest you pull the type out from under Psyco's feet. Pysco, however, usually knows to just fall back to the regular virtual machine if it isn't completely confident the type won't change.

这个故事的寓意是原始数据类型信息实际上是 有助于编译器/虚拟机。

最后，考虑以下情况:执行一个Python程序 由Python解释器/运行在Java上的Java虚拟机实现 解释器/虚拟机在LLVM中实现，运行在qemu虚拟中 在iPhone上运行的机器

永久链接