RandomInteger[{1},20]+1

input=Map[
{α,β}[[#]]&,RandomInteger[{1},20]+1
]

Superscript[α,1]

Map[
Superscript[#,1]&,
input]

f[{...{a_,m_},{a_,n_}...}]:=
f[{...{a,m+n}...}]

Plot3D[Sin[x^2+y^2],
{x,0,3/4 Pi},{y,0,3/4Pi}]

Plot3D[Sin[#1^2+#2^2]&[x,y],
{x,0,3/4 Pi},{y,0,3/4Pi}]

pts={};

Options[Plot3D]

?Lighting

f3D[x_,y_]:=
(pts=Join[pts,{{x,y}}];
Sin[x^2+y^2])

pts={};
plot3d= Plot3D[f3D[x,y],
{x,0,3/4 Pi},{y,0,3/4Pi},
Mesh->None
]
Length[pts]

pts[[3]]

pts3D=Map[{AbsolutePointSize[1],Black,Point[{#[[1]],#[[2]],Sin[#[[1]]^2+#[[2]]^2]}]}&,
pts];

pts3D[[10]]

Graphics3D[{
{AbsolutePointSize[20],White,Point[{1,2,3}]},
{AbsolutePointSize[10],Yellow,Point[{3,1,2}]}
}
]

Show[{
Graphics3D[pts3D],
plot3d}]

t[ _[_, a_]]:=

t[ f_[x_, y_]]:= {f,x,y}

t[g[a,b]]

t[Sin[x,y]]

t[Sin[x+y]]

t[Sin[3+Pi]]

Sin[3+Pi]

Optional arguments

f[a_,b_,c_,mode_:"Lower"]:=
Switch[mode,
"Lower",{{a,0},{b,c}},
"Upper",{{a,b},{0,c}},
mode,Print["I don't understand you"];Abort[]
]

f[Pi,E,3]//MatrixForm

f[Pi,E,3,"Lower"]//MatrixForm

f[Pi,E,3,"lower"]//MatrixForm

isLowerQ[M_]:=M[[1,2]]==0

isLowerQ[{{_,0},{_,_}}]:=True

isLowerQ[_]:=False

isLowerQ[f[1,2,3]]

isLowerQ[f[1,2,3,"Upper"]]

Clear[f]

f[a_^b_]:={a,b}

{
f[1^2],
f[2^1],
f[Pi^(t+y)],
f[(t+y)]
}

ff[a_^(b_:1)]:={a,b}

{
ff[1^2],
ff[2^1],
ff[Pi^(t+y)],
ff[(t+y)]
}

HoldForm[1^2]

Clear[f]

f[{{a_,0,0},
{b_,c_,0},
{d_,e_,f_}}]:={d,e,f}

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

f[{{1,0,0},{4,5,0},{7,8,9}}]

g[{{_,0,0},
{_,_,0},
r:{_,_,_}}]:=r

g[{{1,0,0},{4,5,0},{7,8,9}}]

Recap

f[x_]:= (* general function definition *)

f[x_List]:= (* restricting the type of the arguments *)

f[x_,y_]:= (* multiple arguments *)

f[x_,"a"]:= (* fixing one of the arguments *)

f[x_/?NumberQ[x]]:= 
(* test on argument x *)

f[x_,y_,z_/;condition[z]]:= (* condition on argument z *)

f[x_,y_,z_]/;condition[x,y,z]:=(* condition on arguments *)

f[a_,b__,l___]:=
(* matching one element, a non-empty list of elements, any list  *)

f[a_+b_]:=(* specifying the form of the argument *)

f[{{a_,b_},___}]:=(* again, specifying the shape of the argument *)

f[m:{_^b_}]:=Power[m,-b](* assigning names to parts of a pattern *)

f[a_,b_:Pi]:=Sin[a+b] (* default arguments *)

#&
#1+#2&
##&
Function[{t},t^2]

Function[{t,v},t^2+v]

l =RandomInteger[{10^2,10^3},7]

Map[
#[.5]&,
Map[
Function[{t},Sin[t]^#]&,
l
]
]

Map[#[.5]&,in]

lf={Sin,Cos[#]&,#^3-#&,
Integrate[(1-x^2)/x^2,{x,1,#}]&}

lp={x,y,2.5,Pi};

{
lf[[1]][lp[[1]]],
lf[[2]][lp[[2]]],
...
}

Map[fun,lf,lp]

Map[fun,{lf,lp}]

Map[lf[#]&,lp]

{lf,lp}

{lf,lp}//MatrixForm

Transpose[{lf,lp}]

Map[#[[1]][#[[2]]]&,Transpose[{lf,lp}]]

Map[lf[[#]][lp[[#]]]&,{1,2,3,4}]

MapIndexed

MapThread[g,{lp,lf}]

MapThread[#2[#1]&,{lp,lf}]

Map[g,{arg0,arg1,arg2}]

g/@{arg0,arg1,arg2}

g@@{arg0,arg1,arg2}

Apply[g,{arg0,arg1,arg2}]

g@{arg0,arg1,arg2}

{arg0,arg1,arg2}//g

a~g~b

Clear[f]

f[paolo][x_]:=x^2

f[david][x_]:=x

?f

f[paolo][3]

f[david][3]