2+2

4
Range[10]

{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
NestList[f,x,5]

{x, f[x], f[f[x]], f[f[f[x]]], f[f[f[f[x]]]], f[f[f[f[f[x]]]]]}
List[a,b,c]

{a, b, c}
Plus[2,2]

4
Plus[Power[x,2],Times[3,Power[y,3]]]
Output
ed=Graphics3D[Sphere[]]
Output
EdgeDetect[%]
Output
x

x
ed=Graphics3D[Sphere[]]
Output
ed
Output
{3, 4, 5, 7/8, x, y,
 x^2 + 3 y^3, {a, b,
  c}, [\!\(\*Graphics3DBox[SphereBox[{0, 0, 0}],
      ImageSize -> {46.62109375, Automatic},
      ViewPoint -> {1.3423934952878664`, -2.404165276254038,
        1.9667152890703756`},
      ViewVertical -> {0.009348068236588528, -0.008691644947737727,
        0.9999185311455862}]\)]}

{3, 4, 5, 7/8, x, y,
 x^2 + 3 y^3, {a, b,
  c}, ed}
Output
{a, b, c, d}[[3]]

c
{a, b, c, d, e, f}[[-3]]

d
{1, 2, 3} + 2

{3, 4, 5}
{a, b, c} + {x, y, z}
Output
{a, b, c, d, e, f}[[2 ;; 4]]

{b, c, d}
Table[x^2, {x, 10}]

{1, 4, 9, 16, 25, 36, 49, 64, 81, 100}
Table[f[x], {x, 4, 20, 2}]

{f[4], f[6], f[8], f[10], f[12], f[14], f[16], f[18], f[20]}
Table[f[x], {x, {5, 10, 20, 10, 5}}]

{f[5], f[10], f[20], f[10], f[5]}
Table[i/j,{i,4},{j,2}]
Output
x = 7

7
t := Now

t
Output
t
Output
x =.

t =.

Module[{a = 1}, a + 8]

9
Cases[{f[1], g[2], f[5], g[3]}, f[_]]

{f[1], f[5]}
Replace[f[100], f[x_] -> x + 5]

105
{f[1], g[2], f[5], g[3]} /. f[x_] -> x + 5

{6, g[2], 10, g[3]}
Cases[{f[1, 2], f[1], g[3]}, f[__]]

{f[1, 2], f[1]}
Cases[{f[1], g[2], f[2], f[5], g[3]}, f[1 | 5]]

{f[1], f[5]}
Cases[{f[1], g[2], f[2], f[5], g[3]}, (f | g)[2]]

{g[2], f[2]}
Cases[{1, 2.5, 3.5, 4}, _Real]

{2.5, 3.5}

*In[n] and Out[n] label successive inputs and outputs. You can refer to the most recent output as %—though it's usually better to define a variable.

*Arguments to functions are always separated by commas.

*Everything in the Wolfram Language is a symbolic expression.

numbers strings images arrays graphs formulas documents interfaces code ...

*All symbolic expressions have the same fundamental structure: head[arguments]

*The argument to a function can be any symbolic expression:

FullForm always shows the underlying structure.Head always gives the head of an expression; Length gives the number of arguments.

*It's conventional to start variable names with lowercase letters, reserving capitals for built-in objects: