This is a rough summary of the Python bytecodes in version 1.2.  
See Python/ceval.c for details.

Opcode		Stack effect (pop -> push)
------------------------------------------
POP_TOP		v ->
ROT_TWO		w v -> v w
ROT_THREE	x w v -> v x w
DUP_TOP		v -> v v

UNARY_POS	v -> +v
UNARY_NEG	v -> -v
UNARY_NOT	v -> !v
UNARY_CONV	v -> repr(v)
UNARY_CALL	v -> v()
UNARY_INVERT	v -> ~v
BINARY_MUL	v w -> v*w
BINARY_DIV	v w -> v/w
BINARY_MOD	v w -> v%w
BINARY_ADD	v w -> v+w
BINARY_SUB	v w -> v-w
BINARY_CALL	v w -> v(w)
BINARY_LSHIFT	v w -> v << w
BINARY_RSHIFT	v w -> v >> w
BINARY_AND	v w -> v & w
BINARY_XOR	v w -> v ^ w
BINARY_OR	v w -> v | w
(UNARY_CALL and BINARY_CALL have been replaced by CALL_FUNCTION in v1.3)

COMPARE_OP IS		v w -> v == w
COMPARE_OP ISNOT	v w -> v != w
COMPARE_OP IN		v w -> w in v
COMPARE_OP NOTIN	v w -> !(w in v)
COMPARE_OP EXC		v w -> v == w (exceptions)
also LT, LE, EQ, NE, GT, GE using compare object method

LOAD_CONST x	-> x
LOAD_LOCAL w	-> $w (in local scope only)

LOAD_NAME w	-> $w (check local, then global)
STORE_NAME w	v -> (w=v)
DELETE_NAME w	del w
LOAD_GLOBAL w	-> $w (in global scope only)
STORE_GLOBAL w	v -> (w=v)
DEL_GLOBAL w	del w
LOAD_ATTR w	v -> v.w
STORE_ATTR w	u v -> (v.w = u)
DEL_ATTR w	v -> (del v.w)

BINARY_SUBSCR	v w -> v[w]
STORE_SUBSCR	u v w -> (v[w] = u)
DEL_SUBSCR	v w -> (del v[w])
SLICE+0		u -> u[:]
SLICE+1		u v -> u[v:]
SLICE+2		u w -> u[:w]
SLICE+3		u v w -> u[v:w]
STORE_SLICE+3	t u v w -> (u[v:w] = t)
DEL_SLICE+3	u v w -> (del u[v:w])

PRINT_EXPR	v -> (print(v), _ = v)
PRINT_ITEM	v -> (print(v))
PRINT_NL	putchar('\n')

BUILD_FCN	v -> func(v, f_globals)
SET_FUNC_ARGS	w v -> func v gets arg list w (also an oparg)
BUILD_CLASS	w v u -> build_class(u, v, w) (methods, bases, name)

SETUP_BLOCK	setup_block (for POP_BLOCK)
POP_BLOCK	pop until reach previous stack level (b_level)
BREAK
RAISE_EXC	w v -> w is exception, v is value
RETURN		v ->
END_FINALLY	v -> (v is an exception to reraise; or a return instruction)

LOAD_LOCALS	-> f_locals
LOAD_GLOBALS	-> f_locals
EXEC_STMT	u v w -> (exec u in v,w)  (v is globals, w is locals)

BUILD_TUPLE i	v[0] v[1] ... v[n-1] -> v
BUILD_LIST i	(same as BUILD_TUPLE)
BUILD_MAP	-> new dict
UNPK_VARARG n	v -> v[0] v[1] ... v[n-1] v[n:]
UNPK_TUPLE n	v -> v[0] v[1] ... v[n-1]
UNPK_ARG n	(same as UNPK_TUPLE)
UNPK_LIST n	v -> v[0] v[1] ... v[n-1]

RESERVE_F x	f_localmap = x
LOAD_F i	-> fastlocals[i]
STORE_F i	v -> (fastlocals[i] = v)
DEL_F i		fastlocals[i] = NULL

IMPORT_NAME w	-> __import__.w()
IMPORT_FROM w	v -> (import_from(locals, v, w))
ACCESS_MODE w	v -> (access_stmt(w, v))

JMP_FORWARD n	jmpby(n)
JMP_FALSE n	b -> (b?:jmpby(n))
JMP_TRUE n	b -> (b?jmpby(n):)
JMP_ABS n	jmpto(n)
FOR n		v w -> v w+1 v[w] (if v is exhausted, jmpby(n))