Preface

Be sure you really need to run your task repeatedly. This is called busy waiting and almost always suboptimal. If your task is checking for the output of a subprocess, you can just subprocess.wait() for it to finish, for example. If your task is to wait for a file or directory in the filesystem to be touched, you can use pyinotify to get your code triggered from the filesystem event handled by the kernel.

Answer

This is how you write infinite loop for busy waiting without consuming too much CPU.

Python 2:

from __future__ import print_function
from __future__ import division

import time

while True:
    range(10000)       # some payload code
    print("Me again")  # some console logging
    time.sleep(0.2)    # sane sleep time of 0.1 seconds

Python 3:

import time

while True:
    range(10000)       # some payload code
    print("Me again")  # some console logging
    time.sleep(0.2)    # sane sleep time of 0.1 seconds

Evaluation

As @gnibbler tested in another answer, the presented code should not consume more than 1 % CPU on recent machines. If it still consumes too much CPU with your payload code, consider raising the time to sleep even further. On the other hand, the payload code might need to get optimized for repeated execution. For example, Caching could speed up running on unchanged data.

Credits

This answer tries to builds upon @user2301728's answer.

The Python language predates multi-core CPUs, so it isn't odd that it doesn't use them natively.

Additionally, not all programs can profit from multiple cores. A calculation done in steps, where the next step depends on the results of the previous step, will not be faster using more cores. Problems that can be vectorized (applying the same calculation to large arrays of data) can relatively easy be made to use multiple cores because the individual calculations are independent.

When you are doing a lot of calculations, I'm assuming you're using numpy? If not, check it out. It is an extension written in C that can use optimized linear algebra libraries like ATLAS. It can speed up numerical calculations significantly compared to standard Python.

Having said that, there are several ways to use multiple cores with python.

• Built-in is the multiprocessing module. The multiprocessing.Pool class provides vectorization across multiple CPUs with the map() and related methods. There is a trade-off in here though. If you have to communicate large amounts of data between the processes then that overhead might negate the advantage of multiple cores.
• Use a suitable build of numpy. If numpy is built with a multithreading ATLAS library, it will be faster on large problems.
• Use extension modules like numexpr, parallel python, corepy or Copenhagen Vector Byte Code.

Note that the threading module isn't all that useful in this regard. To keep memory management simple, the global interpreter lock ("GIL") enforces that only one thread at a time can be executing python bytecode. External modules like numpy can use multiple threads internally, though.