Graphing a Function in Python Using Plotnine Library

When it comes to visualizing mathematical functions in Python, libraries such as Plotnine make it easy to create stunning and intuitive plots. Plotnine is built upon the principles of the Grammar of Graphics, which allows users to build complex visualizations layer by layer. In this article, we will explore how to graph a function in Python using Plotnine, walking through various stages of plotting, customization, and function representation.

Introduction to Plotnine

Before we dive into graphing functions, it’s essential to understand what Plotnine is. Plotnine is a Python data visualization library based on R’s popular ggplot2. It follows a consistent and structured approach to plot creation, adhering to the Grammar of Graphics framework. The beauty of Plotnine lies in its simplicity and power—users can build complex plots with a few lines of code.

To get started with Plotnine, you need to install the library. You can easily install it using pip:

pip install plotnine

Once installed, you’re ready to start graphing functions and exploring the various features of Plotnine.

Plotting a Simple Function: Linear Function

Let’s begin by graphing a simple linear function f(x)=2x+1. We’ll first define the function and generate data points, then use Plotnine to visualize the function.

To plot the function, we first need to generate a set of values for the independent variable x and compute the corresponding y values using the function.

import pandas as pd
import numpy as np

# Generate x values
x = np.linspace(-10, 10, 100)

# Define the linear function
y = 2 * x + 1

# Create a DataFrame
df = pd.DataFrame({'x': x, 'y': y})

Now, we’ll create a basic line plot using the geom_line() function from Plotnine, which is used to visualize continuous data.

from plotnine import ggplot, aes, geom_line

# Create the plot
plot = (
    ggplot(df, aes(x='x', y='y')) +
    geom_line()
)

print(plot)

Output:

This code will create a simple line graph showing the linear relationship between x and y.

Customizing the Plot

The power of Plotnine lies in its ability to customize plots extensively. In this section, we’ll explore how to modify the appearance of our graph, from colors to titles and axis labels.

1. Adding Titles and Labels

It’s essential to make your plot informative by adding titles and axis labels.

from plotnine import ggtitle, xlab, ylab

# Customize the plot with titles and labels
plot = (
    ggplot(df, aes(x='x', y='y')) +
    geom_line(color="blue") +
    ggtitle('Graph of Linear Function: y = 2x + 1') +
    xlab('x values') +
    ylab('y values')
)

print(plot)

Output:

2. Modifying Line Appearance

You can change the appearance of the line by modifying parameters such as color, linetype, and size.

plot = (
    ggplot(df, aes(x='x', y='y')) +
    geom_line(color="red", linetype="dashed", size=1.5) +
    ggtitle('Dashed Line Plot of y = 2x + 1')
)

print(plot)

Output:

Plotting Non-linear Functions

In addition to linear functions, Plotnine can be used to visualize non-linear functions such as quadratic, cubic, and trigonometric functions.

1. Quadratic Function

Let’s plot a quadratic function f(x)=x^2

# Define the quadratic function
y = x ** 2

# Create a new DataFrame
df = pd.DataFrame({'x': x, 'y': y})

# Create the plot
plot = (
    ggplot(df, aes(x='x', y='y')) +
    geom_line(color="green") +
    ggtitle('Graph of Quadratic Function: y = x^2') +
    xlab('x values') +
    ylab('y values')
)

print(plot)

Output:

2. Cubic Function

A cubic function like f(x)=x^3 can also be plotted similarly:

# Define the cubic function
y = x ** 3

# Create a DataFrame
df = pd.DataFrame({'x': x, 'y': y})

# Create the plot
plot = (
    ggplot(df, aes(x='x', y='y')) +
    geom_line(color="purple") +
    ggtitle('Graph of Cubic Function: y = x^3')
)

print(plot)

Output:

3. Trigonometric Functions

Plotting trigonometric functions such as sine or cosine is just as easy. Let’s graph

f(x)=sin(x).

# Define the sine function
y = np.sin(x)

# Create a DataFrame
df = pd.DataFrame({'x': x, 'y': y})

# Create the plot
plot = (
    ggplot(df, aes(x='x', y='y')) +
    geom_line(color="orange") +
    ggtitle('Graph of Sine Function: y = sin(x)')
)

print(plot)

Output:

Overlaying Multiple Functions

You can also plot multiple functions on the same graph by adding multiple geom_line() layers. Let’s plot both the quadratic and sine functions on the same graph for comparison.

# Define both functions
y1 = x ** 2
y2 = np.sin(x)

# Create a DataFrame
df = pd.DataFrame({'x': x, 'y1': y1, 'y2': y2})

# Create the plot
plot = (
    ggplot(df) +
    geom_line(aes(x='x', y='y1'), color="blue") +
    geom_line(aes(x='x', y='y2'), color="red") +
    ggtitle('Graph of y = x^2 and y = sin(x)') +
    xlab('x values') +
    ylab('y values')
)

print(plot)

Output:

This code will create a plot that overlays the quadratic and sine functions, with different colors to distinguish between them.

Facetting Plots by Function Type

Another powerful feature of Plotnine is its ability to facet data. This means breaking a plot into multiple subplots based on the values of a variable. Faceting is particularly useful when you want to compare multiple functions or datasets side by side.

Let’s create two subplots for the quadratic and sine functions using facet_wrap().

from plotnine import ggplot, aes, geom_line, facet_wrap, ggtitle
import pandas as pd
import numpy as np

# Generate x values
x = np.linspace(-10, 10, 100)

# Define both functions
y1 = x ** 2
y2 = np.sin(x)

df = pd.DataFrame({'x': x, 'y1': y1, 'y2': y2})

# Melt the DataFrame to long format for faceting
df_melted = pd.melt(df, id_vars=['x'], value_vars=['y1', 'y2'], var_name='function')

# Create the plot with facet_wrap
plot = (
    ggplot(df_melted, aes(x='x', y='value', color='function')) +
    geom_line() +
    facet_wrap('~function') +
    ggtitle('Faceted Plots of y = x^2 and y = sin(x)')
)

print(plot)

Output:

Conclusion

In this article, we explored how to graph various mathematical functions in Python using the Plotnine library. We started with a simple linear function and moved on to non-linear functions such as quadratic, cubic, and trigonometric functions. We also saw how to customize plots, overlay multiple functions, and use facets to compare functions side by side.