How to Use Python with Tableau

Combining Python’s powerful data analysis libraries with Tableau’s best-in-class visualization is a great way to take your dashboards to the next level. By integrating the two, you can run complex models, perform sentiment analysis, or build advanced forecasts directly within your Tableau workbooks. This article will walk you through setting up the connection and provide practical examples for using Python scripts in your Tableau reports.

Why Use Python with Tableau?

Tableau is incredibly powerful for data exploration and visualization, but some analytical tasks can be clunky or even impossible with its built-in functions. Python, on the other hand, is the go-to language for data science, machine learning, and advanced statistical analysis. Bringing them together gives you the best of both worlds:

• Advanced Analytics: Leverage powerful Python libraries like Scikit-learn, Pandas, NLTK, and Statsmodels to perform machine learning, sentiment analysis, and statistical modeling right inside Tableau.
• Sophisticated Data Processing: Handle complex data cleaning and transformation tasks that are difficult to write in Tableau's calculated fields.
• Dynamic Dashboards: Create dashboards that run real-time predictions or classifications on your data as it updates, making your reports more dynamic and insightful.

Instead of doing your analysis in a separate Python environment and importing a static CSV file to Tableau, this integration allows your Python scripts to run live on the data within your workbook.

Prerequisites: What You’ll Need

Before getting started, make sure you have the following set up on your machine:

• Tableau Desktop: This integration works with Tableau Desktop version 10.1 or later.
• Python: A working installation of Python is required. Versions 3.6 or newer are generally recommended for better library compatibility.
• TabPy: The Tableau Python Server, which acts as the bridge between Tableau and Python. We will cover how to install this next.

Step-by-Step Guide to Connecting Python and Tableau

Getting the two tools to communicate involves installing a server, running it in the background, and then pointing Tableau to it. Let’s walk through the exact steps.

1. Install and Run TabPy (Tableau Python Server)

TabPy is a Python package that creates a small server on your computer, listening for and executing any Python code sent from Tableau. To get started, open your terminal or command prompt.

First, install the package using pip:

pip install tabpy

After the installation finishes, you can start the server by simply running the command:

tabpy

If it starts successfully, you will see a message indicating the service has been initialized and is listening on a specific port, which is port 9004 by default. Keep this terminal window open, closing it will shut down the server and break the connection to Tableau.

2. Connect Tableau to the TabPy Server

Now that your local Python server is running, you need to tell Tableau Desktop where to find it.

Open Tableau and follow this path:

1. Go to the top menu and click Help.
2. Navigate to Settings and Performance.
3. Click on Manage Analytics Extension Connection...

A new window will open. Here’s what to do:

• Under Select an Analytics Extension, choose TabPy/External API.
• For the Server, enter localhost.
• For the Port, enter 9004.
• You can leave Sign in with a username and password unchecked unless you have configured specific credentials for your server.
• Click Test Connection. You should see a "Successfully connected" message. If not, double-check that your TabPy server is still running in the terminal.

Once connected, just close the configuration window. You’re all set! Now you can start writing Python scripts within Tableau's calculated fields.

Writing Python Scripts in Tableau Workbooks

The magic happens inside Tableau’s calculated fields. Tableau has four specific functions for sending data to your Python server and receiving a result:

• SCRIPT_REAL(): Returns a real number (float).
• SCRIPT_INT(): Returns an integer.
• SCRIPT_STR(): Returns a string.
• SCRIPT_BOOL(): Returns a boolean (True/False).

The structure of a script looks like this:

SCRIPT_REAL("
# Your Python code goes here
return some_value
", SUM([Sales]))

Any Tableau fields you pass into the function after the script itself are referred to within the Python code as _arg1, _arg2, and so on. For instance, in the example above, SUM([Sales]) would be accessible in the Python script as _arg1.

An important detail to remember is that Tableau sends data to Python as aggregated arrays or lists. For example, SUM([Sales]) isn't a single number but a list of values for each partition (or row of a visualization). Your Python code often needs to loop through these arguments to process them.

Example 1: A Simple Sentiment Analysis of Customer Reviews

A common use case in marketing and product analytics is gauging customer sentiment from feedback or reviews. While this is a complex problem, we can run a simple version using a popular Python library called NLTK (Natural Language Toolkit) right inside a Tableau dashboard.

First, install the required library in your Python environment. Open a new terminal window (don't close your TabPy one) and run this:

pip install nltk pip install vaderSentiment

With the library ready, go to Tableau. Let's assume you have a data source with a column called [Customer Review]. To analyze the sentiment, create a new calculated field named "Sentiment" and enter the following script:

SCRIPT_STR('
from nltk.sentiment.vader import SentimentIntensityAnalyzer

# Initialize the analyzer
sia = SentimentIntensityAnalyzer()
result = []

# Loop through each review sent from Tableau
for text in _arg1:
    sentiment_score = sia.polarity_scores(text)["compound"]
    if sentiment_score >= 0.05:
        result.append("Positive")
    elif sentiment_score <= -0.05:
        result.append("Negative")
    else:
        result.append("Neutral")

return result
', ATTR([Customer Review]))

Drag your new Sentiment calculated field onto the view (e.g., onto the color mark or rows shelf) along with a count of records to instantly see a breakdown of your reviews by sentiment. Every time the data updates or a filter is changed, Tableau re-runs this script to analyze the text live.

Example 2: Forecasting Sales with scikit-learn

Let's tackle a more advanced example: forecasting. Imagine you have monthly sales data and you want to use a simple linear regression model to predict sales for the next 12 months. This is very difficult to do accurately with Tableau's native forecasting but straightforward with Python's scikit-learn library.

Again, install the required libraries first:

pip install scikit-learn pip install pandas

For this to work, you need a view in Tableau that provides the historical data and placeholders for the future periods you want to predict. Let's assume you have monthly data for [Sales] over time.

Create a calculated field called "Sales Forecast" and enter the script below. This script is a bit more complex, so we'll add comments to explain what's happening.

SCRIPT_REAL('
import pandas as pd
from sklearn.linear_model import LinearRegression
import numpy as np

# Create a DataFrame from the incoming Tableau data 
# _arg1 = Sales, _arg2 = Month Numbers
df = pd.DataFrame({"sales": _arg1, "month": _arg2})

# Drop null values for model training
train_df = df.dropna()

# Check if there is data to train on
if len(train_df) == 0:
    return [np.nan] * len(_arg1)

# Fit a simple linear regression model
X = train_df[["month"]]
y = train_df["sales"]
model = LinearRegression()
model.fit(X, y)

# Predict sales for all months (historical and future)
# Future months will have "nan" for sales but a value for the month number
predictions = model.predict(df[["month"]])

return list(predictions)

', SUM([Sales]), ATTR(DATEPART("month", [Order Date])))

This script takes the sales and the month numbers from Tableau, trains a model on the data points that exist, and then predicts values for all months, including future ones included in your Tableau viz. You can then create a dual-axis chart in Tableau to display actual sales and your Python-generated forecast on the same timeline.

Best Practices for Better Performance

Using external services can impact dashboard performance. Here are some tips to keep things running smoothly:

• Keep Scripts Efficient: The complexity of your Python script directly affects calculation speed. Optimize your code wherever possible.
• Pre-calculate Where Possible: For huge datasets, consider running more intensive analytics offline in a dedicated Python script and storing the results. Use the Tableau integration for more dynamic, interactive calculations on smaller or aggregated data.
• Manage Your Python Environment: Make sure the environment where TabPy is running has all the necessary libraries installed. Mismatched environments are a common source of errors.
• Use the TabPy Console for Debugging: The terminal window where TabPy is running will show detailed Python error messages, which are incredibly helpful for debugging your scripts when Tableau just shows a generic error.

Final Thoughts

Integrating Python with Tableau bridges the gap between sophisticated data science and interactive data visualization. By setting up TabPy, you can embed powerful models and complex data transformations directly into your dashboards, delivering deeper, more dynamic insights than either tool could offer alone.

For teams who want the power of advanced analytics without the setup hassle, we built Graphed to act as your AI data analyst. You can connect sources like GA4 or Salesforce in a click and simply describe the reports you need in plain English. Graphed automatically generates real-time dashboards and gets you answers in seconds, replacing the need to write and debug Python scripts or configure complex servers. Grab your free account to get started with Graphed today.