Attributes
Definitions such as
f[x_]=x^2 specify
values for functions. Sometimes, however, you need to specify general properties of functions, without necessarily giving explicit values.
Mathematica provides a selection of
attributes that you can use to specify various properties of functions. For example, you can use the attribute
Flat to specify that a particular function is "flat", so that nested invocations are automatically flattened, and it behaves as if it were associative.
This assigns the attribute Flat to the function f. 
Now f behaves as a flat, or associative, function, so that nested invocations are automatically flattened.
Out[2]=  

Attributes like
Flat can affect not only evaluation, but also operations such as pattern matching. If you give definitions or transformation rules for a function, you must be sure to have specified the attributes of the function first.
Here is a definition for the flat function f. 
Because f is flat, the definition is automatically applied to every subsequence of arguments.
Out[4]=  

Manipulating attributes of symbols.
This shows the attributes assigned to f.
Out[5]=  

This removes the attributes assigned to f.
Out[6]=  

Orderless  orderless, commutative function (arguments are sorted into standard order) 
Flat  flat, associative function (arguments are "flattened out") 
OneIdentity  f[f[a]], etc. are equivalent to a for pattern matching 
Listable  f is automatically "threaded" over lists that appear as arguments (e.g., f[{a, b}] becomes {f[a], f[b]}) 
Constant  all derivatives of f are zero 
NumericFunction  f is assumed to have a numerical value when its arguments are numeric quantities 
Protected  values of f cannot be changed 
Locked  attributes of f cannot be changed 
ReadProtected  values of f cannot be read 
HoldFirst  the first argument of f is not evaluated 
HoldRest  all but the first argument of f is not evaluated 
HoldAll  none of the arguments of f are evaluated 
HoldAllComplete  the arguments of f are treated as completely inert 
NHoldFirst  the first argument of f is not affected by N 
NHoldRest  all but the first argument of f is not affected by N 
NHoldAll  none of the arguments of f are affected by N 
SequenceHold  Sequence objects appearing in the arguments of f are not flattened out 
Temporary  f is a local variable, removed when no longer used 
Stub  Needs is automatically called if f is ever explicitly input 
The complete list of attributes for symbols in Mathematica.
Here are the attributes for the builtin function Plus.
Out[7]=  

An important attribute assigned to builtin mathematical functions in
Mathematica is the attribute
Listable. This attribute specifies that a function should automatically be distributed or "threaded" over lists that appear as its arguments. This means that the function effectively gets applied separately to each element in any lists that appear as its arguments.
This defines the function p to be listable. 
Now p is automatically threaded over lists that appear as its arguments.
Out[10]=  

Many of the attributes you can assign to functions in
Mathematica directly affect the evaluation of those functions. Some attributes, however, affect only other aspects of the treatment of functions. For example, the attribute
OneIdentity affects only pattern matching, as discussed in
"Flat and Orderless Functions". Similarly, the attribute
Constant is only relevant in differentiation, and operations that rely on differentiation.
The
Protected attribute affects assignments.
Mathematica does not allow you to make any definition associated with a symbol that carries this attribute. The functions
Protect and
Unprotect discussed in
"Modifying Builtin Functions" can be used as alternatives to
SetAttributes and
ClearAttributes to set and clear this attribute. As discussed in
"Modifying Builtin Functions" most builtin
Mathematica objects are initially protected so that you do not make definitions for them by mistake.
Here is a definition for the function g.
Out[11]=  

Now you cannot modify the definition of g.
Out[13]=  

You can usually see the definitions you have made for a particular symbol by typing
?f, or by using a variety of builtin
Mathematica functions. However, if you set the attribute
ReadProtected,
Mathematica will not allow you to look at the definition of a particular symbol. It will nevertheless continue to use the definitions in performing evaluation.
Although you cannot modify it, you can still look at the definition of g. 
Now you can no longer read the definition of g. 
Functions like
SetAttributes and
ClearAttributes usually allow you to modify the attributes of a symbol in any way. However, if you once set the
Locked attribute on a symbol, then
Mathematica will not allow you to modify the attributes of that symbol for the remainder of your
Mathematica session. Using the
Locked attribute in addition to
Protected or
ReadProtected, you can arrange for it to be impossible for users to modify or read definitions.
Clear[f]  remove values for f, but not attributes 
ClearAll[f]  remove both values and attributes of f 
Clearing values and attributes.
This clears values and attributes of p which was given attribute Listable above. 
By defining attributes for a function you specify properties that
Mathematica should assume whenever that function appears. Often, however, you want to assume the properties only in a particular instance. In such cases, you will be better off not to use attributes, but instead to call a particular function to implement the transformation associated with the attributes.
By explicitly calling Thread, you can implement the transformation that would be done automatically if p were listable.
Out[19]=  

Functions that perform transformations associated with some attributes.
Attributes in
Mathematica can only be permanently defined for single symbols. However,
Mathematica also allows you to set up pure functions which behave as if they carry attributes.
Function[vars,body,{attr_{1},...}]  a pure function with attributes attr_{1}, ... 
Pure functions with attributes.
This pure function applies p to the whole list.
Out[20]=  

By adding the attribute Listable, the function gets distributed over the elements of the list before applying p.
Out[21]=  
