Python 3d:

OpenGL -- Underlying graphics language. Offers the most
flexibility. If you want to do anything fancy (programmable shaders,
etc), you need to use OpenGL. It also has the nice property that it is
the industry standard. Knowing how to use it is useful, since it is
the most common and widely applicable graphics language. It is
unlikely to go away at any point, and it is more-or-less the same
under any platform and in any language. The downside is that it is the
most difficult to use, and requires the most code for common, simple
tasks.

On top of OpenGL, there are a variety of higher-level frameworks. In
OpenGL, there is a display function. OpenGL calls this function
whenever it needs to render a window. The user needs to manually write
the function to draw all the polygons in the specified places,
whenever OpenGL wants to redraw the scene. The frameworks, in
contrast, handle this themselves. The user tells the framework a
high-level command to the effect of "place a ball at 10,20,5," and the
framework will keep drawing the ball in that position, whenever
necessary, until the user tells the framework to move or get rid of
the ball. Some frameworks even support higher-level constructs, such
as "place a ball moving along this predefined path."

Soya is a framework designed for videogames. As a result, it offers a
fairly easy way to do effects like transparency, shadows, metallics,
etc. It has these disadvantages:
* Not very well documented
* Small project -- may not exist in a few years
* Python-specific

OpenInventor is a decade-old framework from SGI, now released as free
software. Prior to the freeing of OpenInventor, a free (GPL) clone
called COIN was developed. OpenInventor is explicitly designed for
scientific visualization, and has a very nice framework for this. It
has the following advantages:
* Not as big as OpenGL, but fairly large userbase. File format is
  fairly standard.
* Multiple, open implementations. 
* Easy-to-use
* Nice viewer (you can do things like create a scene and use OI's
  built-in viewer, which lets the user control camera position and
  zoom with a friendly mouse UI). This lets you build very powerful
  visualization apps with minimal work.
Disadvantages (when I last used it): 
* Old, in some ways, reaching obsolescence
* Does not support modern OpenGL features, such as transparency, etc. 
* Python bindings are fairly immature/unstable

Both high-level frameworks differ in interface from OpenGL fairly 
significantly. OpenGL calls your code whenever it wants to redraw the 
window, and you place polygons. In both frameworks, you place objects, 
and they stick around until you modify them. This makes them much 
faster and easier to use. 

All of these rely on callbacks to do work. None of them have the nice 
property where the rendering code runs in a seperate thread, and is 
told to do things when the programmer wants them done, rather than 
when the framework gets idle time.