Why can't python vectorize map() or list comprehensions
You want vectorization or JIT compilation use numba, pypy or cython but be warned the speed comes at the cost of flexibility. 
numba is a python module that will jit compile certain functions for you but it does not support many kinds of input and barfs on some (many) python constructs. It is really fast when it works but can be difficult to wrangle. It is also very targeted at working with numpy arrays.
pypy is a complete replacement for the cpython interpreter that is a JIT. It supports the entire python spec but does not integrate with extensions well so some libraries will not work.
cython is an extension of python which compiles to a binary which will behave like a python module. However it does require you to use special syntax to take advantage of the speed gains and requires you to explicitly declare things as ctypes to real get any advantage.
My recommendation is:
use pypy if you are pure python. (if it works for you it's basically effortless)
Use numba if you need to speed up numeric calculations that numpy doesn't have a good way to do.
Use cython if you need the speed and the other 2 don't work.
I don't know that much about vectorization, but I am interested in understanding why a language like python can not provide vectorization on iterables through a library interface, much like it provides threading support. I am aware that many numpy methods are vectorized, but it can be limiting to have to work with numpy for generic computations.
My current understanding is that python is not capable of vectorizing functions even if they match the "SIMD" pattern. For instance, in theory shouldn't any list comprehension or use of the map() function be vectorizable because they output a list which is the result of running the same function on independent inputs from an input list? 
With my niave understanding, it seems that anytime I use map(), in theory, I should be able to create an instruction set that represents the function; then each element in the input just needs to be run through the same function that was compiled. What is the technical challenge to designing a tool that provides simd_map(func, iterable), which attempts to compile func "just in time" and then grabs batches of input from iterable and utilizes the processor's simd capabilities to run those batches through func()?
Thanks!