Cases

Cases[{e1,e2,},pattern]

gives a list of the ei that match the pattern.

Cases[{e1,},patternrhs]

gives a list of the values of rhs corresponding to the ei that match the pattern.

Cases[expr,pattern,levelspec]

gives a list of all parts of expr on levels specified by levelspec that match the pattern.

Cases[expr,patternrhs,levelspec]

gives the values of rhs that match the pattern.

Cases[expr,pattern,levelspec,n]

gives the first n parts in expr that match the pattern.

Cases[pattern]

represents an operator form of Cases that can be applied to an expression.

Details and Options

  • The first argument to Cases need not have head List.
  • When used on an Association, Cases picks out elements according to their values.
  • Cases[expr,pattern:>rhs] evaluates rhs only when the pattern is found.
  • Cases[pattern][list] is equivalent to Cases[list,pattern].
  • Cases uses standard level specifications:
  • nlevels 1 through n
    Infinitylevels 1 through Infinity
    {n}level n only
    {n1,n2}levels n1 through n2
  • The default value for levelspec in Cases is {1}.
  • A positive level n consists of all parts of expr specified by n indices.
  • A negative level -n consists of all parts of expr with depth n.
  • Level -1 consists of numbers, symbols, and other objects that do not have subparts.
  • Level 0 corresponds to the whole expression.
  • With the option setting Heads->True, Cases looks at heads of expressions, and their parts.
  • Cases traverses the parts of expr in a depth-first order, with leaves visited before roots.

Examples

open allclose all

Basic Examples  (4)

Find cases that explicitly match integers:

Find cases that do not match integers:

Return the x from inside each f[x_] matched:

Use the operator form of Cases:

Pick elements from an Association:

Scope  (10)

Find all cases of lists of two elements:

Find the sum of every pair of elements:

Pick out elements that are not 0:

Pick out cases of integers down to level 2:

Return only the first three matching elements:

Use :> to evaluate only after explicit elements have been found:

Find all possible subexpressions at any level:

Find all possible subexpressions at any level, including the head of the expression:

Pick elements from nested associations:

Pick elements from a List matching an Association:

Find keys of each matching Association:

Pick pairs of keys from each association in a list:

Find associations with the key satisfying a condition:

Options  (1)

Heads  (1)

Find symbols among the elements of an expression:

Also include the head of the expression in the search:

Properties & Relations  (1)

Count returns the length of the result given by Cases:

Possible Issues  (1)

A rule transforms the matching elements into its right side:

Use HoldPattern to treat the rule itself as a pattern:

Introduced in 1988
 (1.0)
 |
Updated in 2003
 (5.0)
2014
 (10.0)