Applying Functions to Parts of Expressions

If you have a list of elements, it is often important to be able to apply a function separately to each of the elements. You can do this in Mathematica using Map.

This applies separately to each element in a list.
In[1]:=
Click for copyable input
Out[1]=
This defines a function which takes the first two elements from a list.
In[2]:=
Click for copyable input
You can use Map to apply to each element of a list.
In[3]:=
Click for copyable input
Out[3]=
Map[f,{a,b,...}]apply f to each element in a list, giving

Applying a function to each element in a list.

What Map[f, expr] effectively does is to "wrap" the function f around each element of the expression expr. You can use Map on any expression, not just a list.

This applies to each element in the sum.
In[4]:=
Click for copyable input
Out[4]=
This applies Sqrt to each argument of .
In[5]:=
Click for copyable input
Out[5]=

Map[f, expr] applies f to the first level of parts in expr. You can use MapAll[f, expr] to apply f to all the parts of expr.

This defines a 2x2 matrix .
In[6]:=
Click for copyable input
Out[6]=
Map applies to the first level of , in this case the rows of the matrix.
In[7]:=
Click for copyable input
Out[7]=
MapAll applies at all levels in . If you look carefully at this expression, you will see an wrapped around every part.
In[8]:=
Click for copyable input
Out[8]=

In general, you can use level specifications as described in "Levels in Expressions" to tell Map to which parts of an expression to apply your function.

This applies only to the parts of at level 2.
In[9]:=
Click for copyable input
Out[9]=
Setting the option Heads->True wraps around the head of each part, as well as its elements.
In[10]:=
Click for copyable input
Out[10]=
Map[f,expr] or f/@exprapply f to the first-level parts of expr
MapAll[f,expr] or f//@exprapply f to all parts of expr
Map[f,expr,lev]apply f to each part of expr at levels specified by lev

Ways to apply a function to different parts of expressions.

Level specifications allow you to tell Map to which levels of parts in an expression you want a function applied. With MapAt, however, you can instead give an explicit list of parts where you want a function applied. You specify each part by giving its indices, as discussed in "Parts of Expressions".

Here is a 2x3 matrix.
In[11]:=
Click for copyable input
Out[11]=
This applies to parts and .
In[12]:=
Click for copyable input
Out[12]=
This gives a list of the positions at which occurs in .
In[13]:=
Click for copyable input
Out[13]=
You can feed the list of positions you get from Position directly into MapAt.
In[14]:=
Click for copyable input
Out[14]=
To avoid ambiguity, you must put each part specification in a list, even when it involves only one index.
In[15]:=
Click for copyable input
Out[15]=
MapAt[f,expr,{part1,part2,...}]apply f to specified parts of expr

Applying a function to specific parts of an expression.

Here is an expression.
In[16]:=
Click for copyable input
Out[16]=
This is the full form of .
In[17]:=
Click for copyable input
Out[17]//FullForm=
You can use MapAt on any expression. Remember that parts are numbered on the basis of the full forms of expressions.
In[18]:=
Click for copyable input
Out[18]=
MapIndexed[f,expr]apply f to the elements of an expression, giving the part specification of each element as a second argument to f
MapIndexed[f,expr,lev]apply f to parts at specified levels, giving the list of indices for each part as a second argument to f

Applying a function to parts and their indices.

This applies to each element in a list, giving the index of the element as a second argument to .
In[19]:=
Click for copyable input
Out[19]=
This applies to both levels in a matrix.
In[20]:=
Click for copyable input
Out[20]=

Map allows you to apply a function of one argument to parts of an expression. Sometimes, however, you may instead want to apply a function of several arguments to corresponding parts of several different expressions. You can do this using MapThread.

MapThread[f,{expr1,expr2,...}]apply f to corresponding elements in each of the
MapThread[f,{expr1,expr2,...},lev]apply f to parts of the at the specified level

Applying a function to several expressions at once.

This applies to corresponding pairs of list elements.
In[21]:=
Click for copyable input
Out[21]=
MapThread works with any number of expressions, so long as they have the same structure.
In[22]:=
Click for copyable input
Out[22]=

Functions like Map allow you to create expressions with parts modified. Sometimes you simply want to go through an expression, and apply a particular function to some parts of it, without building a new expression. A typical case is when the function you apply has certain "side effects", such as making assignments, or generating output.

Scan[f,expr]evaluate f applied to each element of expr in turn
Scan[f,expr,lev]evaluate f applied to parts of expr on levels specified by lev

Evaluating functions on parts of expressions.

Map constructs a new list in which has been applied to each element of the list.
In[23]:=
Click for copyable input
Out[23]=
Scan evaluates the result of applying a function to each element, but does not construct a new expression.
Scan visits the parts of an expression in a depth-first walk, with the leaves visited first.
New to Mathematica? Find your learning path »
Have a question? Ask support »