First things first. Load in SymPy, the engine to do symbolic calculations, and optionally IPython "display", which lets you render LaTeX equations in IPython notebooks using MathJax, after you execute the "init-(underscore)-printing" command.
from sympy import *
from IPython.display import display
init_printing(use_latex='mathjax')
%matplotlib inline
Symbolic variables need to be defined before they are used. One can also define the type and scope of the variable. This might allow the SymPy engine to apply additional simplifications.
x, y, z = symbols('x, y, z')
m = symbols('m', integer=True)
f = symbols('f', cls=Function)
a, b = symbols('a, b', real=True, positive=True)

expr1 = x + 1

print expr1, type(expr1)
One can plot the expression to see what it looks like
plot(expr1,(x,0,3),title='simple plot', xlabel='x', ylabel='x+1')
Note that, in general, the python variable "x" is different from the SymPy variable "x".

You can use the "subs" command to do substitutions.
expr = x+y**2*sin(x); print expr.subs(x,1)
You can substitute multiple variables at once
print expr.subs({x:1, y:2})
And in case, you need to do non-sequential substitution:
print expr.subs([(x,y), (y,x)], simultaneous=True)
One can take any polynomial, and write it out in the canonical expanded form using "expand", and back factor them using the command "factor". The iPython command "display" lets you typeset using MathJax.
expandedForm = expand((x+2)*(x-3)); display(expandedForm)

display(factor(expandedForm))

display(factor(expandedForm + 7 - x))
If you have an expression with multiple variables, you can "collect" or rewrite it in terms of a particular variable. 
expr = x*y + x - 3 + 2*x**2 - z*x**2 + x**3; display(expr)

collected_expr = collect(expr, x); display(collected_expr)
You can use trig identities (sum and double angle identities) to expand out arguments, or carry out simplifications.
display(expand_trig(sin(x + y))) # uses sum/double angle utilities

display(trigsimp(sin(x)**4 - 2*cos(x)**2*sin(x)**2 + cos(x)**4))  # applies trig identities
The multi-purpose simplification command is "simplify"
a = (x + 1)**2
b = x**2 + 2*x + 1
display(simplify(a - b))

c = x**2 - 2*x + 1
display(simplify(a - c))
These are often extremely handy time-savers.The generic command is "diff", you can take derivatives of different order, and with respect to different variables
f = (x-1)**m * exp(x); display(f)
Usual first ordered derivative
diff(f,x)
Second and higher order order derivatives
diff(f,x,2)

g = simplify(x - f/diff(f,x)); display(g)
One can generate LaTeX output to embed in a document easily;
latex(diff(f, x))

intg = integrate(sin(x**2), (x, -oo, oo)); display(intg)

intg = integrate(x**x, (x, 0, 1)); display(intg); plot(x**x, (x,0,1))
It couldn't find a closed for expression for the integral. One can evaluate the integral numerically using "N" or "evalf" modules, and optionally request the number of significant digits.
print intg.evalf(10) # Like N[expr,10] in Mathematica
print N(intg, 30)
"series", lets you carry out a taylor series expansion around a point up to a specified order. The "O" notation can be suppressed if required.
expr = exp(sin(x))
display(expr.series(x, 0, 4))

display(expr.series(x, 0, 4).removeO())
One can also do Taylor series of two variables using a one-liner
expr = sin(x*cos(y)); display(expr)

expr.series(x, 0, 3).removeO().series(y, 0, 3).removeO()
Another handy command is summation
j = symbols('j',integer=True, positive=True)
expr = summation(j**2, (j,1,m)); display(expr)

expr = x**2 + 3*x + 2
print solve(expr)

expr1 = x + y - 2
expr2 = x - y - 4
print solve([expr1, expr2],(x,y))

from sympy.physics import units as u

print u.watt

mph = u.mile / u.hour
mps = u.meter / u.second

print N(mps/mph), "mph = 1 mps"