Lookup

Lookup[assoc,key]

looks up the value associated with key in the association assoc; if the key is not present, Missing["KeyAbsent",key] is returned.

Lookup[assoc,{key1,key2,}]

gives a list of the values associated with the keyi.

Lookup[{assoc1,assoc2,},key]

gives a list corresponding to the value of key in each associ.

Lookup[assoc,key,default]

gives default if the key is not present.

Lookup[assoc,keys,default,h]

looks up the values associated with keys, wrapping each of then with head h before evaluation

Lookup[key]

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

Details

  • In Lookup[assoc,key,default], default is only evaluated if key is not found in assoc.
  • Lookup can be applied not only to Association objects, but also to lists of rules.
  • Lookup[assoc,Key[list]] treats the list list as a single key rather than a list of keys.
  • Lookup[{assoc1,assoc2,},{key1,key2,}] gives an array of the form {{assoc1[key1],assoc1[key2],},}.
  • Lookup[key][assoc] is equivalent to Lookup[assoc,key].

Examples

open allclose all

Basic Examples  (4)

Look up the value associated with the key:

When a key is not found, a Missing object is returned by default:

Provide a default value to be used when the key is not found:

Use the operator form of Lookup:

Scope  (5)

Look up multiple keys at once:

Lookup threads over lists of associations:

Query multiple keys from multiple associations:

Lookup can be used to look up keys in lists of rules:

Wrap the result in Hold to prevent it from evaluating:

Apply the operator form to a list of lists:

Applications  (1)

You can use constructs such as Throw and Return in the third argument of Lookup to abort a computation when a required key is missing:

Properties & Relations  (4)

When the key is present, the default is not evaluated:

Even when it appears in a result multiple times, the default value is only evaluated once:

Applying an association to a key is typically equivalent to using Lookup on that key:

Lists are handled differently by Lookup, however:

Wrap the list in Key to make Lookup treat it as a single key:

Lookup automatically strips up to one level of Key from its second argument:

Similarly, lists of keys are stripped of any Key wrappers they contain:

This stripping allows looking up expressions of the form Key[{}] and Key[Key[]]:

Possible Issues  (1)

When the key to be looked up is a list or an expression with head Key, it must be wrapped in a Key to avoid ambiguity:

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

Text

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

BibTeX

@misc{reference.wolfram_2020_lookup, author="Wolfram Research", title="{Lookup}", year="2020", howpublished="\url{https://reference.wolfram.com/language/ref/Lookup.html}", note=[Accessed: 02-December-2020 ]}

BibLaTeX

@online{reference.wolfram_2020_lookup, organization={Wolfram Research}, title={Lookup}, year={2020}, url={https://reference.wolfram.com/language/ref/Lookup.html}, note=[Accessed: 02-December-2020 ]}

CMS

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

APA

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