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.
  • Parallelize[Cases[expr,pattern]] computes Cases[expr,pattern] in parallel on all subkernels. »

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  (2)

Count returns the length of the result given by Cases:

Compute Cases in parallel:

Possible Issues  (1)

A rule transforms the matching elements into its right side:

Use HoldPattern to treat the rule itself as a pattern:

Wolfram Research (1988), Cases, Wolfram Language function, https://reference.wolfram.com/language/ref/Cases.html (updated 2014).

Text

Wolfram Research (1988), Cases, Wolfram Language function, https://reference.wolfram.com/language/ref/Cases.html (updated 2014).

CMS

Wolfram Language. 1988. "Cases." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2014. https://reference.wolfram.com/language/ref/Cases.html.

APA

Wolfram Language. (1988). Cases. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/Cases.html

BibTeX

@misc{reference.wolfram_2024_cases, author="Wolfram Research", title="{Cases}", year="2014", howpublished="\url{https://reference.wolfram.com/language/ref/Cases.html}", note=[Accessed: 22-November-2024 ]}

BibLaTeX

@online{reference.wolfram_2024_cases, organization={Wolfram Research}, title={Cases}, year={2014}, url={https://reference.wolfram.com/language/ref/Cases.html}, note=[Accessed: 22-November-2024 ]}