Lists are widely used in the Wolfram Language, and there are many ways to construct them.

Often you will know in advance how long a list is supposed to be, and how each of its elements should be generated. And often you may get one list from another.

Sometimes you may want to accumulate a list of results during the execution of a program. You can do this using Sow and Reap.

An alternative but less efficient approach involves introducing a temporary variable, then starting with t={}, and successively using AppendTo[t,elem].

You can always reset one or more pieces of a list by doing an assignment like m[[…]]=value.

It is sometimes useful to think of a nested list as being laid out in space, with each element at a coordinate position given by its indices. There is then a direct geometrical interpretation for list[[spec₁,spec₂,…]]. If a given spec_k is a single integer, then it represents extracting a single slice in the k ^th dimension, while if it is a list, it represents extracting a list of parallel slices. The final result for list[[spec₁,spec₂,…]] is then the collection of elements obtained by slicing in each successive dimension.

Part is set up to make it easy to pick out structured slices of nested lists. Sometimes, however, you may want to pick out arbitrary collections of individual parts. You can do this conveniently with Extract.

An important feature of Extract is that it takes lists of part positions in the same form as they are returned by functions like Position.

Much like Part, Take and Drop can be viewed as picking out sequences of slices at successive levels in a nested list, you can use Take and Drop to work with blocks of elements in arrays.

It is important to understand that ReplacePart always creates a new list. It does not modify a list that has already been assigned to a symbol the way m[[…]]=val does.

Functions like Array, SparseArray, and Outer always generate full arrays, in which all sublists at a particular level are the same length.

The Wolfram Language can handle arbitrary nested lists. There is no need for the lists to form a full array. You can easily generate ragged arrays using Table.

Partition in effect goes through a list, grouping successive elements into sublists. By default it does not include any sublists that would "overhang" the original list.

You can tell Partition to include sublists that overhang the ends of the original list. By default, it fills in additional elements by treating the original list as cyclic. It can also treat it as being padded with elements that you specify.

You can think of Partition as extracting sublists by sliding a template along and picking out elements from the original list. You can tell Partition where to start and stop this process.

An alignment specification {k_L,k_R} tells Partition to give the sequence of sublists in which the first element of the original list appears at position in the first sublist, and the last element of the original list appears at position in the last sublist.

Functions like ListConvolve use the same alignment and padding specifications as Partition.

In some cases it may be convenient to insert explicit padding into a list. You can do this using PadLeft and PadRight.

PadLeft, PadRight, and Partition can all be used on nested lists.

If you give a nested list as a padding specification, its elements are picked up cyclically at each level.

Lists are normally specified in the Wolfram Language just by giving explicit lists of their elements. But particularly in working with large arrays, it is often useful instead to be able to say what the values of elements are only at certain positions, with all other elements taken to have a default value, usually zero. You can do this in the Wolfram System using SparseArray objects.

An important feature of SparseArray is that the positions you specify can be patterns.

You can think of SparseArray[rules] as taking all possible position specifications, then applying rules to determine values in each case. As usual, rules given earlier in the list will be tried first.

For many purposes, the Wolfram System treats SparseArray objects just like the ordinary lists to which they correspond. Thus, for example, if you ask for parts of a sparse array object, the Wolfram System will operate as if you had asked for parts in the corresponding ordinary list.

Many operations treat SparseArray objects just like ordinary lists. When possible, they give sparse arrays as results.

The Wolfram System represents sparse arrays as expressions with head SparseArray. Whenever a sparse array is evaluated, it is automatically converted to an optimized standard form with structure SparseArray[Automatic,dims,val,…].

This structure is, however, rarely evident, since even operations like Length are set up to give results for the corresponding ordinary list, not for the raw SparseArray expression structure.