Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://reference.wolfram.com/language/ref/Lookup.html below:

Lookup—Wolfram Language Documentation

We deliver solutions for the AI era—combining symbolic computation, data-driven insights and deep technology expertise.

• Data & Computational Intelligence
• Model-Based Design
• Algorithm Development
• Wolfram|Alpha for Business
• Blockchain Technology
• Education Technology
• Quantum Computation

WolframConsulting.com

• See Also
  • Association
  • Part
  • Key
  • KeyExistsQ
  • Normal
  • Replace
  • OptionValue
  • Missing
• Related Guides
  • Associations
  • Computation with Structured Datasets
  • Language Overview

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,{key₁,key₂,…}]

gives a list of the values associated with the key_i.

Lookup[{assoc₁,assoc₂,…},key]

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

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 them with head h before evaluation.

Lookup[key]

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

• 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[{assoc₁,assoc₂,…},{key₁,key₂,…}] gives an array of the form {{assoc₁[key₁],assoc₁[key₂],…},…}.
• Lookup[key][assoc] is equivalent to Lookup[assoc,key].

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:

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:

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:

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[…]]:

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:

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4