Compiling means changing something from one source language into another. The traditional meaning is compiling a high level language into machine code which is then assembled into opcodes. That's not the only way to do it though, Python is first compiled into a bytecode (a more compact representation of the source code checked for syntax errors) and that bytecode is interpreted.
Interpreters are easier to write because it is not as much work supporting different architectures compared to compiling the code. Also, interpreting small amounts of code that will only be run once is typically faster than compiling it and then optimizing and executing it.
Compiling however has much greater potential speedups. A compiler can make a decision at compile time once, and that decision never has to be made again. In an interpreted language that decision might have to be remade on every iteration of a loop.
As you move up from more powerful languages than C, the languages get harder and harder to compile because you know intrinsically less at compile time. In C for example, every variable is known at compile time, so every variable lookup can be translated into a read from some offset from the stack frame pointer, which is very fast. The C compiler will keep a hash table at compile time to keep track of these offsets, but at run time that information is no longer available. In Python, you don't know all the variables that are going to be looked up at compile time, so you have to do those expensive hash table lookups at run time.
In the end, naively generating code for a dynamic and reflective language won't yield that much of a speedup without some serious optimization passes, which was typically not very helpful because the higher level languages were used as glue code to high performance libraries or programs. As people become more interested in using these languages for more intensive work expect to see more effort at compiling then, although most will probably be compiled into a virtual machine bytecode and then compiled to native machine code by the JVM or CLR.