When working with data as a data science or data analyst, it’s important to be able to find the basic descriptive statistics of a set of data.

There are many major companies and industries which use SAS (banking, insurance, etc.), but with the rise of open source and the popularity of languages such as Python and R, these companies are exploring converting their code to Python.

One of the most commonly used procedures in SAS is the PROC MEANS procedure. In this article, you’ll learn the Python equivalent of PROC MEANS (and note, getting a Python equivalent of PROC SUMMARY and PROC HPSUMMARY will be similar).

This article contains the following examples (you can skip to one using the links below or keep reading to reach them sequentially):

When using PROC MEANS, we need to provide a dataset, class and analysis variables, statistical options, and output datasets.

Below is an example of PROC MEANS which we will replicate in Python.

Let’s say we have data such as the following:


In SAS, we can read this in using a XLSX libname statement or PROC IMPORT.

Next, we want to get some descriptive statistics using PROC MEANS.

PROC MEANS Equivalent in Python

In SAS, when we want to find the descriptive statistics of a variable in a dataset, we use the PROC MEANS procedure.

Below is the PROC MEANS I’m going to replicate in Python:


The output from this PROC MEANS is below:


To get the Python equivalent of PROC MEANS, we will use the pandas library of Python, and utilize the describe() function:

import pandas as pd
import numpy as np

df = pd.read_excel(path + "example_data.xlsx")

#count 8.00000
#mean 26.25000
#std   8.34523
#min  15.00000
#25%  20.00000
#50%  25.00000
#75%  31.25000
#max  40.00000
#Name: height, dtype: float64

As you can see, we get the same results, except for the percentiles. That is because the pandas .describe() function does a linear interpolation. To get the quantile, you should use the quantile() function.

PROC MEANS with OUTPUT Statement Equivalent in Python

Many times, we want to take the descriptive statistics from a data and create new data with these statistics.

With PROC MEANS, we can add an output statement and get the following outputted dataset.



Doing this in Python is super easy. All you need to do is store the outputted DataFrame in a variable:

example_out1 = df["height"].describe()

Now, you can use this new DataFrame like any other DataFrame – just like the outputted dataset in SAS.

PROC MEANS with Multiple Variables and OUTPUT Statement Equivalent in Python

Of course, when doing data analysis, usually we want to look at multiple variables and multiple groups.

In SAS, adding another analysis variable is very easy. Below is the PROC MEANS from above with the “weight” variable now added.


Here’s the output and output dataset.



To replicate this PROC MEANS in Python, all you need to do is add another variable when subsetting the DataFrame.

example_out2 = df[["height","weight"]].describe()


#       height    weight
#count 8.00000  8.000000
#mean 26.25000 48.125000
#std   8.34523 22.350695
#min  15.00000 20.000000
#25%  20.00000 28.750000
#50%  25.00000 50.000000
#75%  31.25000 62.500000
#max  40.00000 80.000000

PROC MEANS with NMISS Equivalent in Python

One thing that the describe() function does not do is calculated the number of missing values.

To calculate the number of missing values in SAS with PROC MEANS is easily done with the NMISS option.


The output of the above PROC MEANS shows no missing values for the “height” variable:proc-means-nmiss-results

To get the number of missing values of a series in Python, we use the isnull() and sum() functions.

nmiss = df["height"].isnull().sum()



PROC MEANS with CLASS Statement Equivalent in Python

Next, when doing data analysis, usually, we want to find descriptive statistics by different groups.

For our data, for example, we have the “type” variable and this variable has different types of animal.

When presenting our data, we know that dogs are different than cats, and cats are different than pigs.

When creating the PROC MEANS to get the descriptive statistics by group, all we need to do is add CLASS to the PROC MEANS.

The output from this PROC MEANS is shown below:


Here is the outputted dataset from the above PROC MEANS:


To get the Python equivalent of PROC MEANS with a CLASS statement, we can do the following.

The pandas DataFrame has a function groupby() which allows you to group the data.

Using this function, we can get the same output as above:

example_out3 = df.groupby("type")["height"].describe().reset_index()


#   type count  mean       std  min  25%  50%  75%  max
#0   Cat   3.0  20.0  5.000000 15.0 17.5 20.0 22.5 25.0
#1   Dog   2.0  30.0 14.142136 20.0 25.0 30.0 35.0 40.0
#2   Pig   3.0  30.0  5.000000 25.0 27.5 30.0 32.5 35.0

To get exactly the outputted data from above, we can keep only the columns we want (mean and std), and rename those columns.

example_out3.rename(columns={"mean":"height_avg", "std":"height_std"}, inplace=True)

example_out3 = example_out3[["type","height_avg","height_std"]]


#    type height_avg height_std
#0    Cat       20.0   5.000000
#1    Dog       30.0  14.142136
#2    Pig       30.0   5.000000

PROC MEANS with CLASS Statement, Multiple Variables and OUTPUT Statement Equivalent in Python

Finally, to finish up, if we want to have multiple variables, this is done in a similar way to above in Python.

Below is the PROC MEANS which we will be replicating in Python:


The output from the PROC MEANS is below:


The SAS dataset which is outputted is below:


To get this same structure, we need to do a little bit more work.

The first thing we can try is just add “weight” when subsetting the DataFrame after the application of groupby():

example_out4 = df.groupby("type")[["height","weight"]].describe()

This gives us the summary statistics we want, but it doesn’t quite give us the output that we are looking for. This returns a DataFrame of DataFrames – which makes working with it a little more involved than the previous examples.

We can try to use the merge() function, but things get messy fast. Also, if we wanted to do more than 2 variables, we would have to merge many times.

example_out4 = example_out4["height"].reset_index().merge(example_out4["weight"].reset_index(),on="type")

But, this works for our example – to get the output dataset, we would just need to rename some columns and then we can get the same output dataset:

example_out4.rename(columns={"mean_x":"height_avg", "std_x":"height_std","mean_y":"weight_avg", "std_y":"weight_std"}, inplace=True)

example_out4 = example_out4[["type","height_avg","height_std","weight_avg","weight_std"]]

#   type height_avg  height_std   weight_avg   weight_std
#0   Cat       20.0    5.000000         25.0     5.000000
#1   Dog       30.0   14.142136         50.0    14.142136
#2   Pig       30.0    5.000000         70.0    10.000000

However, as I mentioned above, while the code above works, it’s messy. Check out this article for how to group by multiple columns and summarize data with pandas.

The function below I prefer for finding the descriptive statistics of a DataFrame given a group variable. This function works well for relatively small datasets.

def proc_means_equiv_w_class(ds,analysis_vars,group_var):
    levels = pd.unique(ds[group_var])
    df = pd.DataFrame()
    for i in range(0,len(levels)):
        temp2=temp[analysis_vars.split(" ")].describe().transpose()             
        df = df.append(temp2, ignore_index=True)
    df.rename(columns={"25%":"p25", "75%":"p75", "50%": "median", "count":"n", "index":"var"}, inplace=True)
    return df[['level','var','nmiss','n','mean','median','std','min','max','p25','p75']]

analysis = "height weight"
group = "type"


#    level      var nmiss   n mean median         std   min    max  p25   p75
#0     Dog   height     0 2.0 30.0   30.0   14.142136  20.0   40.0 25.0  35.0
#1     Dog   weight     0 2.0 50.0   50.0   14.142136  40.0   60.0 45.0  55.0
#2     Cat   height     0 3.0 20.0   20.0    5.000000  15.0   25.0 17.5  22.5
#3     Cat   weight     0 3.0 25.0   25.0    5.000000  20.0   30.0 22.5  27.5
#4     Pig   height     0 3.0 30.0   30.0    5.000000  25.0   35.0 27.5  32.5
#5     Pig   weight     0 3.0 70.0   70.0   10.000000  60.0   80.0 65.0  75.0

I hope that this article has given you everything you need to know about converting your PROC MEANS procedure into Python code.

Categorized in:


Last Update: April 1, 2024