Wolfram: Cases (Filter List by pattern)

Get elements by Pattern.

For each element, it is tested against the pattern, but only at level 1 of the expression. 〔see Wolfram: Pattern Matching and Level Spec〕

• Cases

Cases[ {a, f[3], f[9]}, f[_] ]
(* {f[3], f[9]} *)

Cases[ {a, f[3], g[4], f[5]}, _[_] ]
(* {f[3], g[4], f[5]} *)

Cases[ {{2}, {4, 8}, {c}}, {_ , _} ]
(* {{4, 8}} *)

(* ways to get numbers *)

Cases[ {3, 0, -1, 2.2, Pi, x, 2/3}, _Integer ]
(* {3, 0, -1} *)

Cases[ {3, 0, -1, 2.2, Pi, x, 2/3}, _Rational ]
(* {2/3} *)

Cases[ {3, 0, -1, 2.2, Pi, x, 2/3}, _Symbol ]
(* {Pi, x} *)

(* head is one of Complex Integer Real Rational *)
Cases[ {3, 0, -1, 2.2, Pi, x, 2/3}, _?NumberQ ]
(* {3, 0, -1, 2.2, 2/3} *)

Cases[ {3, 0, -1, 2.2, Pi, x, 2/3}, _?Positive ]
(* {3, 2.2, Pi, 2/3} *)

Cases[ {3, 0, -1, 2.2, Pi, x, 2/3}, _?NumericQ ]
(* {3, 0, -1, 2.2, Pi, 2/3} *)

(* Cases match a pattern against each element, but only at level 1 *)

Cases[ { {1,{2,{3,4}}} }, {_Integer , _Integer}]

(* {} *)

(* none found.
because it tries to match
{1,{2,{3,4}}}
at level 1 only.
which it sees
{1,{...}}
where the second part is not a integer.
*)

(* HHHH------------------------------ *)

(* if you want to get {3,4}, you need to specify a level spec. *)

Cases[ { {1,{2,{3,4}}} }, {_Integer , _Integer}, {1,Infinity} ]

(* {{3, 4}} *)

replace result by rhs.

Cases[ {3, 2.2, 2/3}, x_Integer -> x + 1]
(* {4} *)

limit search to Level Spec. Default to {1}.

(* example of level spec *)

Cases[ {3,4}, _ , {1}]
(* {3, 4} *)

Cases[ {3,4}, _ , {1, Infinity}]
(* {3, 4} *)

Cases[ {3,4}, _ , {0, Infinity}]
(* {3, 4, {3, 4}} *)

limit search to Level Spec, then replace result by rhs

Show only first n result.

Delete elements by Pattern.

• DeleteCases

DeleteCases[ {1, 3, 2, 4}, 2 ]
(* {1, 3, 4} *)

DeleteCases[ {a, b, c}, c ]
(* {a, b} *)

DeleteCases[ {a, f[3], c}, f[3] ]
(* {a, c} *)

DeleteCases[ {a, f[3], g[4], f[5]}, f[_] ]
(* {a, g[4]} *)

DeleteCases[ {{2}, {4, 8}, {c}}, {_ , _} ]
(* {{2}, {c}} *)