In order to select a single column from a DataFrame object, you can index the DataFrame with the corresponding column label or a nonzero integer.

Such a column is returned as a DataSeries object. This is the same DataSeries object that is part of the original DataFrame: modifying it later will change the DataFrame.

Indexing with a positive integer i that is at most the number of columns of the DataFrame will return the ith column of the DataFrame.

df[2];

$\left[\begin{array}{cc}a& 0\\ b& 2\\ c& 4\end{array}\right]$

Indexing with a negative integer -i that is at least minus the number of entries of the DataFrame will return the ith column from the right.

df[-2];

$\left[\begin{array}{cc}a& \mathrm{-2}\\ b& 0\\ c& 2\end{array}\right]$

Indexing with a label that is not of one of the forms above will yield the column corresponding to that label.

df[C];

$\left[\begin{array}{cc}a& \mathrm{-1}\\ b& 1\\ c& 3\end{array}\right]$

In order to select a contiguous range of columns from a DataFrame object, you can index the DataFrame with a range, for example, df[a .. b].

Such a range of columns is returned as a new DataFrame object. The columns of this new object, however, are the same DataSeries objects that make up the original DataFrame that was indexed. Thus, later modifying these columns will modify the original DataFrame.

If the left hand side of the range is missing, it will be taken to be the first column. If the right hand side is missing, it will be taken to be the last column. In particular, if both are missing, as in df[ .. ], you obtain a copy of the full DataFrame.

df[ .. ];

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 1& 0& \mathrm{-1}& \mathrm{-2}& \mathrm{-3}\\ b& 3& 2& 1& 0& \mathrm{-1}\\ c& 5& 4& 3& 2& 1\end{array}\right]$

Otherwise, the left and right-hand side are interpreted as single entries (shown above).

df[D .. ];

$\left[\begin{array}{ccc}& \mathrm{D}& E\\ a& \mathrm{-2}& \mathrm{-3}\\ b& 0& \mathrm{-1}\\ c& 2& 1\end{array}\right]$

df[B .. -3];

$\left[\begin{array}{ccc}& B& C\\ a& 0& \mathrm{-1}\\ b& 2& 1\\ c& 4& 3\end{array}\right]$

In order to create a DataFrame with arbitrarily selected and reordered columns, you can index it with a list or Vector (or another 1-dimensional rtable, such as an Array). Each entry of such a list or Vector is interpreted according to rules similar to what is listed above for a single index. Details follow in the next few items.

Such a subset of columns is returned as a new DataFrame object. The columns of this new object, however, are the same DataSeries objects that make up the original DataFrame that was indexed. Thus, later modifying these columns will modify the original DataFrame.

If all entries of col are integers that are in absolute value at most equal to the number of columns of df, then each entry represents a position. The columns at these positions are gathered up into a new DataFrame. Zero entries in col are replaced with columns that are filled with undefined. (These are considered missing values.)

df[[1, 2, 4]];

$\left[\begin{array}{cccc}& A& B& \mathrm{D}\\ a& 1& 0& \mathrm{-2}\\ b& 3& 2& 0\\ c& 5& 4& 2\end{array}\right]$

df[<-3, -2, 2>];

$\left[\begin{array}{cccc}& C& \mathrm{D}& B\\ a& \mathrm{-1}& \mathrm{-2}& 0\\ b& 1& 0& 2\\ c& 3& 2& 4\end{array}\right]$

Otherwise, all entries of col are considered to be labels. Any entry that occurs as a column label in df is replaced by that column. Any other value is replaced with a column of undefined values. Note that a single value that is not an integer, or is not in the appropriate range, changes the interpretation to this mechanism.

df[[B, D, C]];

$\left[\begin{array}{cccc}& B& \mathrm{D}& C\\ a& 0& \mathrm{-2}& \mathrm{-1}\\ b& 2& 0& 1\\ c& 4& 2& 3\end{array}\right]$

df[[D, E, F, 2]];

$\left[\begin{array}{ccccc}& \mathrm{D}& E& 1& 2\\ a& \mathrm{-2}& \mathrm{-3}& \mathrm{undefined}& \mathrm{undefined}\\ b& 0& \mathrm{-1}& \mathrm{undefined}& \mathrm{undefined}\\ c& 2& 1& \mathrm{undefined}& \mathrm{undefined}\end{array}\right]$

In order to select some of the rows of a DataFrame df, you can use a Boolean DataSeries dsb. This is done by matching the labels of dsb to the row labels of df, and returning a new DataFrame df_result consisting of those rows of df that match a label in dsb, where the corresponding value in dsb is true. All rows occur in the order they were in df.

dsb := DataSeries([true, FAIL, false, true, true], labels = [c, b, 3, a, coconut]);

$\mathrm{dsb}≔\left[\begin{array}{cc}c& \mathrm{true}\\ b& \mathrm{FAIL}\\ 3& \mathrm{false}\\ a& \mathrm{true}\\ \mathrm{coconut}& \mathrm{true}\end{array}\right]$

df[dsb];

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 1& 0& \mathrm{-1}& \mathrm{-2}& \mathrm{-3}\\ c& 5& 4& 3& 2& 1\end{array}\right]$

The values for the labels a and c in dsb are true, so these rows are returned. The value for the label coconut is also true, but it does not occur in df, so it is discarded. Note also that, while the label c precedes a in dsb, it's the other way around in df, and that is reflected in the result.

Using Boolean DataSeries is particularly useful because you can create them by performing comparison operations on DataSeries. You can also combine Boolean DataSeries by using logical operators. This is illustrated in the following examples.

dsb2 := df[5] <~ 0;

$\mathrm{dsb2}≔\left[\begin{array}{cc}a& \mathrm{true}\\ b& \mathrm{true}\\ c& \mathrm{false}\end{array}\right]$

dsb3 := isprime~(df[1]);

$\mathrm{dsb3}≔\left[\begin{array}{cc}a& \mathrm{false}\\ b& \mathrm{true}\\ c& \mathrm{true}\end{array}\right]$

dsb4 := dsb2 xor dsb3;

$\mathrm{dsb4}≔\left[\begin{array}{cc}a& \mathrm{true}\\ b& \mathrm{false}\\ c& \mathrm{true}\end{array}\right]$

df[dsb4];

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 1& 0& \mathrm{-1}& \mathrm{-2}& \mathrm{-3}\\ c& 5& 4& 3& 2& 1\end{array}\right]$

You can put the previous few computations on a single line, too:

df[df[5] <~ 0 xor isprime~(df[1])];

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 1& 0& \mathrm{-1}& \mathrm{-2}& \mathrm{-3}\\ c& 5& 4& 3& 2& 1\end{array}\right]$

If you index a DataFrame df with a Boolean DataFrame dfb, then Maple determines for each column of df if there is a column in dfb with the same label. It then determines for each row of df if there is a row in dfb with the same label. Finally, it creates a new DataFrame df_result with the same rows and columns as df, and for each entry, if there is a row and column with the same label in dfb, it determines if the corresponding value in dfb is true. If this is the case, the entry is copied from df to df_result. If the row label is missing from dfb, or the column label is missing from dfb, or the corresponding value in dfb is false or FAIL, then Maple fills that entry with the number 0.

dfb := DataFrame(Matrix(3, 5, (i, j) -> not (isprime(i) xor isprime(j))), rows=[b,c,d], columns=[A,B,D,E,F]);

$\mathrm{dfb}≔\left[\begin{array}{cccccc}& A& B& \mathrm{D}& E& F\\ b& \mathrm{true}& \mathrm{false}& \mathrm{false}& \mathrm{true}& \mathrm{false}\\ c& \mathrm{false}& \mathrm{true}& \mathrm{true}& \mathrm{false}& \mathrm{true}\\ d& \mathrm{false}& \mathrm{true}& \mathrm{true}& \mathrm{false}& \mathrm{true}\end{array}\right]$

df[dfb];

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 0& 0& 0& 0& 0\\ b& 3& 0& 0& 0& \mathrm{-1}\\ c& 0& 4& 0& 2& 0\end{array}\right]$

Let n be the number of columns of df. This case applies if col is a nonzero integer between -n and n, or a column label of df.

If value is a Matrix or DataFrame and it has a single row or column, then Maple will interpret it as a row or column Vector and process it as explained below. Otherwise, an error is raised.

If value is a Vector or a DataSeries, then it needs to have exactly the same number of elements as there are rows in df. The entries are matched in order. If value is a DataSeries, its labels are ignored.

Otherwise, each entry in the selected column is assigned value.

df[2] := 3;

${\mathrm{df}}_2≔3$

df;

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 1& 3& \mathrm{-1}& \mathrm{-2}& \mathrm{-3}\\ b& 3& 3& 1& 0& \mathrm{-1}\\ c& 5& 3& 3& 2& 1\end{array}\right]$

df[C] := <2, 4, 5>;

${\mathrm{df}}_C≔\left[\begin{array}{c}2\\ 4\\ 5\end{array}\right]$

df;

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 1& 3& 2& \mathrm{-2}& \mathrm{-3}\\ b& 3& 3& 4& 0& \mathrm{-1}\\ c& 5& 3& 5& 2& 1\end{array}\right]$

df[-2] := Matrix([3, -1, 2]);

${\mathrm{df}}_{\mathrm{-2}}≔\left[\begin{array}{ccc}3& \mathrm{-1}& 2\end{array}\right]$

df;

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 1& 3& 2& 3& \mathrm{-3}\\ b& 3& 3& 4& \mathrm{-1}& \mathrm{-1}\\ c& 5& 3& 5& 2& 1\end{array}\right]$

Let n be the number of columns of df. This case applies if col is of the form a .. b, where a and b are either missing (so that we have .. b or a .. or  .. ) or nonzero integers between - n and n, or labels of df.

If value is a Matrix or DataFrame and it has the same number of rows as df and as many columns as are referenced by the range col, then the entries are matched in order and overwritten. Otherwise, it needs to have a single row or column, and Maple will interpret it as a Vector and process it as explained below. If value is a DataFrame, its labels are ignored.

If value is a Vector or a DataSeries, then it needs to have exactly the number of rows of df. Every column is overwritten with these values. They are matched to the rows in order. If value is a DataSeries, its labels are ignored.

Otherwise, each entry in the range is assigned value.

df[D .. -1] := 3;

${\mathrm{df}}_{\mathrm{D}..\mathrm{-1}}≔3$

df;

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 1& 3& 2& 3& 3\\ b& 3& 3& 4& 3& 3\\ c& 5& 3& 5& 3& 3\end{array}\right]$

df[C .. -2] := <1, 2, -2>;

${\mathrm{df}}_{C..\mathrm{-2}}≔\left[\begin{array}{c}1\\ 2\\ \mathrm{-2}\end{array}\right]$

df;

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 1& 3& 1& 1& 3\\ b& 3& 3& 2& 2& 3\\ c& 5& 3& \mathrm{-2}& \mathrm{-2}& 3\end{array}\right]$

This case applies if col is a Vector, a list, or an Array.

Like in the case of selecting or rearranging entries, explained above, the values in col are interpreted as positions if all of them are integers between -n and n, where n is the number of columns of df. Otherwise, the values in col are interpreted as labels. Both zero positions and missing labels are ignored.

If value is a Matrix or a DataFrame object and it has exactly as many rows as df does, and as many columns as col has entries, then for all i and j, the ith entry of column col[j] of df is overwritten with value[i, j].

Otherwise, value needs to have a single row or column, and Maple will interpret it as a Vector and process it as explained below.

If value is a Vector or a DataSeries object, then it must have exactly as many entries as df has rows. For each column that is overwritten, Maple assigns value[i] to the ith entry of that column.

Otherwise, value is assigned to each entry in each column that is overwritten.

df[<C, B>] := <4, 2, 1>;

${\mathrm{df}}_{⟨C\&comma;B⟩}≔\left[\begin{array}{c}4\\ 2\\ 1\end{array}\right]$

df;

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 1& 4& 4& 1& 3\\ b& 3& 2& 2& 2& 3\\ c& 5& 1& 1& \mathrm{-2}& 3\end{array}\right]$

df[[2, 3]] := df[[4, 1]];

${\mathrm{df}}_{\left[2\&comma;3\right]}≔\left[\begin{array}{ccc}& \mathrm{D}& A\\ a& 1& 1\\ b& 2& 3\\ c& \mathrm{-2}& 5\end{array}\right]$

df;

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 1& 1& 1& 1& 3\\ b& 3& 2& 3& 2& 3\\ c& 5& \mathrm{-2}& 5& \mathrm{-2}& 3\end{array}\right]$

This case applies if bool is a Boolean DataSeries object. It selects rows to overwrite based on the index. In all cases, the rows of df that would occur in df[bool] are overwritten and the other rows are not.

Consider the case where value is a Matrix. If it has the same number of columns as df, then for each i, if the ith row is overwritten, it is overwritten with values from the ith row of value. This means that value should typically have at least as many rows as df does (though strictly speaking, it is only necessary that it has as many rows as the position of the last occurring row that would occur in df[bool]).

Otherwise, value needs to have a single row or column, and Maple will interpret it as a Vector and process it as explained below.

Consider the case where value is a Vector. For each i, if the ith row is overwritten, all its entries will be overwritten with value[i]. This means that value should typically have at least as many entries as df as rows (though strictly speaking, it is only necessary that it has as many entries as the position of the last row that would occur in df[bool]).

Consider the case where value is a DataFrame. In this case, value needs to have the same number of columns as df. If a row is overwritten and the row label does not occur as a row label in value, then it is filled with 0. If the row label does occur in value, then Maple copies the entries of that row, in order, to df. The column labels are ignored.

Finally, consider the case where value is a DataSeries object. In this case, if a row is overwritten and the row label occurs as a label in value, all entries of that row in df are overwritten with the corresponding entry in value. If the row label does not occur, the entries are overwritten with 0.

In all other cases, each entry of df that would occur in df[bool] is overwritten with value.

dsb;

$\left[\begin{array}{cc}c& \mathrm{true}\\ b& \mathrm{FAIL}\\ 3& \mathrm{false}\\ a& \mathrm{true}\\ \mathrm{coconut}& \mathrm{true}\end{array}\right]$

df[dsb] := <5, 4, 3>;

${\mathrm{df}}_{\mathrm{dsb}}≔\left[\begin{array}{c}5\\ 4\\ 3\end{array}\right]$

df;

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 5& 5& 5& 5& 5\\ b& 3& 2& 3& 2& 3\\ c& 3& 3& 3& 3& 3\end{array}\right]$

df2 := DataFrame(Matrix(4, 5, (i, j) -> i + 2*j), rows = [a, c, d, b], columns = [C, D, F, A, B]);

$\mathrm{df2}≔\left[\begin{array}{cccccc}& C& \mathrm{D}& F& A& B\\ a& 3& 5& 7& 9& 11\\ c& 4& 6& 8& 10& 12\\ d& 5& 7& 9& 11& 13\\ b& 6& 8& 10& 12& 14\end{array}\right]$

dsb2;

$\left[\begin{array}{cc}a& \mathrm{true}\\ b& \mathrm{true}\\ c& \mathrm{false}\end{array}\right]$

df[dsb2] := df2;

${\mathrm{df}}_{\mathrm{dsb2}}≔\left[\begin{array}{cccccc}& C& \mathrm{D}& F& A& B\\ a& 3& 5& 7& 9& 11\\ c& 4& 6& 8& 10& 12\\ d& 5& 7& 9& 11& 13\\ b& 6& 8& 10& 12& 14\end{array}\right]$

df;

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 3& 5& 7& 9& 11\\ b& 6& 8& 10& 12& 14\\ c& 3& 3& 3& 3& 3\end{array}\right]$

df[dsb] := 5;

${\mathrm{df}}_{\mathrm{dsb}}≔5$

df;

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 5& 5& 5& 5& 5\\ b& 6& 8& 10& 12& 14\\ c& 5& 5& 5& 5& 5\end{array}\right]$

This case applies if bool is a Boolean DataFrame object. It selects entries to overwrite based on the index. In all cases, the entries of df that would be copied into df[bool] are overwritten and the other entries are not.

Consider the case where value is a Matrix. If it has a single row or column, Maple will interpret it as a Vector and process it as explained below. Otherwise, for each i and j, if df[i, j] is overwritten, it is overwritten with value[i, j].  This means that value should typically have at least as many rows as df does (though strictly speaking, it is only necessary that it has as many rows as the position of the last row that would be used to provide entries in df[bool], and as many columns as the position of the last column that would be used to provide entries in df[bool]).

Consider the case where value is a Vector. For each i and j, if df[i, j] is overwritten, it is overwritten with value[i].  This means that value should typically have at least as many entries as df has rows (though strictly speaking, it is only necessary that it has as many entries as the position of the last row that would be used to provide entries in df[bool]).

Consider the case where value is a DataFrame. If an entry is to be overwritten, then if its row and column label do not occur as a row and column label in value, respectively, it is overwritten with 0. If the row and column label do occur, the entry is overwritten with the entry of value that has the corresponding row and column label.

Finally, consider the case where value is a DataSeries object. In this case, if an entry is to be overwritten, then if its row label does not occur as a label in value, it is overwritten with 0. If the row label does occur, the entry is overwritten with the entry of value that has the corresponding label.

In all other cases, each entry of df that would occur in df[bool] is overwritten with value.

df[dfb] := 23;

${\mathrm{df}}_{\mathrm{dfb}}≔23$

df;

$\left[\begin{array}{cccccc}& A& B& C& \mathrm{D}& E\\ a& 5& 5& 5& 5& 5\\ b& 23& 8& 10& 12& 23\\ c& 5& 23& 5& 23& 5\end{array}\right]$

df2;

$\left[\begin{array}{cccccc}& C& \mathrm{D}& F& A& B\\ a& 3& 5& 7& 9& 11\\ c& 4& 6& 8& 10& 12\\ d& 5& 7& 9& 11& 13\\ b& 6& 8& 10& 12& 14\end{array}\right]$

df[not~ dfb] := df2;

${\mathrm{df}}_{{\mathrm{`~`}}_{\mathrm{not}}\left(\mathrm{dfb}\&comma;\$\right)}≔\left[\begin{array}{cccccc}& C& \mathrm{D}& F& A& B\\ a& 3& 5& 7& 9& 11\\ c& 4& 6& 8& 10& 12\\ d& 5& 7& 9& 11& 13\\ b& 6& 8& 10& 12& 14\end{array}\right]$