Basic Examples (9) 

Look up part of an expression:

In[1]:=

Out[1]=

If the specified part is not found, a Missing object is returned:

In[2]:=

Out[2]=

Providing a third argument allows the default value to be provided:

In[3]:=

Out[3]=

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

In[4]:=

Out[4]=

Look up multiple parts:

In[5]:=

Out[5]=

In[6]:=

Out[6]=

Use Span syntax to look up a sequence of parts:

In[7]:=

Out[7]=

In[8]:=

Out[8]=

In[9]:=

Out[9]=

Count from the end of the list:

In[10]:=

Out[10]=

In[11]:=

Out[11]=

In[12]:=

Out[12]=

Use UpTo in a Span specification:

In[13]:=

Out[13]=

In[14]:=

Out[14]=

Use the operator form:

In[15]:=

Out[15]=

In[16]:=

Out[16]=

In[17]:=

Out[17]=

In[18]:=

Out[18]=

Scope (9) 

Using zero as the part specification corresponds to the head of an expression:

In[19]:=

Out[19]=

Look up a nested part:

In[20]:=

Out[20]=

In[21]:=

Out[21]=

In[22]:=

Out[22]=

Get multiple nested parts:

In[23]:=

Out[23]=

In[24]:=

Out[24]=

Use a mix of part specifications:

In[25]:=

Out[25]=

Get the second column of a matrix:

In[26]:=

Out[26]=

Get part of an association by key:

In[27]:=

Out[27]=

In[28]:=

Out[28]=

Get part of an association by position:

In[29]:=

Out[29]=

In[30]:=

Out[30]=

Get a nested part of an association:

In[31]:=

Out[31]=

Or equivalently:

In[32]:=

Out[32]=

Use Unevaluated to look up part of the expression before it evaluates:

In[33]:=

Out[33]=

Only the returned part will evaluate:

In[34]:=

Out[34]=

In[35]:=

Out[35]=

Applications (1) 

Create variants of First and Last that return a Missing object when the list is empty:

In[36]:=

Out[36]=

In[37]:=

Out[37]=

In[38]:=

Out[38]=

In[39]:=

Out[39]=

In[40]:=

Out[40]=

In[41]:=

Out[41]=

Properties and Relations (9) 

LookupPart operates on the FullForm of expressions:

In[42]:=

Out[42]=

In[43]:=

Out[43]=

LookupPart returns the default value instead of failing if the first argument is atomic:

In[44]:=

Out[44]=

Compare to Part:

In[45]:=

Out[45]=

LookupPart[0] is equivalent to Head:

In[46]:=

Out[46]=

In[47]:=

Out[47]=

LookupPart[Sequence[]] is equivalent to Identity:

In[48]:=

Out[48]=

LookupPart has the SequenceHold attribute:

In[49]:=

Out[49]=

Part does not, so these are equivalent:

In[50]:=

Out[50]=

In[51]:=

Out[51]=

Using a Sequence as a part specification is similar to a Fold over the parts:

In[52]:=

Out[52]=

In[53]:=

Out[53]=

In[54]:=

Out[54]=

When the default value is not specified, LookupPart defaults to a Missing object that contains elements corresponding to what would be issued in a message when using Part:

In[55]:=

Out[55]=

In[56]:=

Out[56]=

In[57]:=

Out[57]=

In[58]:=

Out[58]=

Specifying part 0 always* succeeds without evaluating the third argument:

In[59]:=

Out[59]=

* Unless it doesn’t:

In[60]:=

LookupPart has the NHoldAll attribute, so its operator form won’t be affected by N:

In[61]:=

Out[61]=

In[62]:=

Out[62]=

Possible Issues (2) 

Unlike Lookup, the second argument of LookupPart behaves like the second argument of Part, so keys to associations must be wrapped in Key:

In[63]:=

Out[63]=

In[64]:=

Out[64]=

Attempting to use the key directly results in an error:

In[65]:=

Out[65]=

This is also true for Part:

In[66]:=

Out[66]=

However, if the keys are strings, Key is not necessary:

In[67]:=

Out[67]=

In[68]:=

Out[68]=

When using Span or All part specifications, LookupPart does not return partial results if any part of the sequence is missing:

In[69]:=

Out[69]=

In[70]:=

Out[70]=

This behavior is consistent with Part:

In[71]:=

Out[71]=

In this case, use of Map can yield partial results:

In[72]:=

Out[72]=

Neat Examples (1) 

Create a new lookup function with a neat default value:

In[73]:=

In[74]:=

Out[74]=

In[75]:=

Out[75]=