Sometimes you just want to look at a small subset of your data. Luckily, CAS makes this fairly easy to do through the use of WHERE clauses and variable lists. If you are using CASTable objects in Python, you can also use DataFrame-like operations on them to filter your view of the data as well. We'll look at some examples of both of these here.
The first thing we need to do is create a CAS connection.
In [1]:
import swat
conn = swat.CAS(host, port, username, password)
Now we need some data to work with, so we'll upload the cars data set.
In [2]:
cars = conn.read_csv('https://raw.githubusercontent.com/sassoftware/sas-viya-programming/master/data/cars.csv')
cars
Out[2]:
Using the len function in Python and the table.columinfo action, we can get some more information about the data in the CAS table. We see that it has 428 rows and 15 columns of data.
In [3]:
len(cars)
Out[3]:
In [4]:
cars.table.columninfo()
Out[4]:
Let's say that we only want to see the sports cars. We can do this in one of two ways. We could set the where parameter on the CASTable object to contain the string 'Type = "Sports"', or we could use the DataFrame data selection syntax. Let's look at the where parameter first.
To apply a WHERE clause to a CASTable, we can manually set the where attribute to the expression we want to apply.
In [5]:
cars.where = 'Type = "Sports"'
cars
Out[5]:
We can look at the length and a sample of the data to see that it has been subset.
In [6]:
len(cars)
Out[6]:
In [7]:
cars.head()
Out[7]:
Let's remove the where attribute and look at the DataFrame-like ways of subsetting data.
In [8]:
del cars.where
cars
Out[8]:
The query method on the CASTable object mimics the query method of DataFrames. However, in this case, the syntax of the expression is the same as a CAS WHERE clause. So we use the same expression from above as the argument to the query method.
In [9]:
cars.query('Type = "Sports"').head()
Out[9]:
Unlike setting the where parameter on the CASTable object, the query method does not embed the parameter in the CASTable object. It creates a copy of the table. If you want to apply the query to the CASTable object, you would add the inplace=True option.
In [10]:
cars.query('Type = "Sports"', inplace=True)
cars
Out[10]:
A very popular way of subsetting the data in a DataFrame is using Python's getitem syntax (i.e., df[...]). You can use that same syntax on CASTable objects. First, we need to delete the WHERE clause that we had embedded using the last query method.
In [11]:
del cars.where
cars
Out[11]:
The way to subset a table using DataFrame syntax is to index a CASTable object (e.g., cars[...]) using a condition on a column of that CASTable (e.g., cars.Type == 'Sports'). The condition is applied to the CASTable as a filter.
In [12]:
cars[cars.Type == 'Sports'].head()
Out[12]:
The way this works is the condition creates a computed column that is treated as a mask. If you look at the result of the expression, you'll see that it creates a computed column describing the expression.
In [13]:
cars.Type == 'Sports'
Out[13]:
If you look at a sample of the data created by the computed column, you'll see that it is a series of ones and zeros.
In [14]:
(cars.Type == 'Sports').head(40)
Out[14]:
When this mask is applied to a table, only the rows where the condition is true (i.e., computed expression is equal to one) show up in the output.
In [15]:
cars[cars.Type == 'Sports'].head()
Out[15]:
It is also possible to combine expressions using Python's & and | operators. Due to the order of operations, you need to surround each subexpression with parentheses.
In [16]:
cars[(cars.Type == 'Sports') & (cars.Cylinders > 6)].head()
Out[16]:
Alternatively, you can chain your subsets which also results in combining those conditions into a single filter.
In [17]:
cars[cars.Type == 'Sports'][cars.Cylinders > 6].head()
Out[17]:
If you want to see what's going on behind the scenes, you can always store the result in a variable. The resulting object is simply another CASTable object with a WHERE clause and computed columns for the expressions.
In [18]:
sports8 = cars[cars.Type == 'Sports'][cars.Cylinders > 6]
sports8
Out[18]:
In [19]:
conn.close()
We've shown two different ways of filtering data in a CAS table. First we showed how you could manually apply a WHERE clause to a CASTable object. The next way of filtering data was based on the Pandas DataFrame API. You can either use the query method with a WHERE clause, or you can use the getitem syntax of Python to generate computed columns and WHERE clauses based on Python syntax.
In [ ]: