- \n
- Introduction<\/a><\/li>\n
- Syntax<\/a><\/li>\n
- Examples<\/a><\/li>\n
- Frequently Asked Questions<\/a><\/li>\n<\/ul>\n
Alternatively, if you want to understand how to use the sns.lineplot function, we have a separate tutorial on sns.lineplot<\/a>.<\/p>\n
With all that said, let’s start with an introduction.<\/p>\n
<\/a><\/p>\n
A quick introduction to the Seaborn Lineplot<\/h2>\n
As the name implies, a “lineplot” is a plot that contains …<\/p>\n
… wait for it …<\/p>\n
Lines<\/strong>.<\/p>\n
The lineplot (AKA, line chart<\/a>) is a tool that we commonly use to plot time series data, or some sort of data that changes over time.<\/p>\n
In Python, there are several tools for creating lineplots, including the Matplotlib
plot()<\/code> function and the traditionalsns.lineplot()<\/code> function.<\/p>\nBut in this tutorial, I’ll show you how to use the Seaborn Objects API to create a lineplot.<\/p>\n
You can use the Seaborn Objects visualization system to create line charts with a single line:<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/02\/simple-seaborn-lineplot_one-line.png\")
<\/p>\nAnd you can also use the Seaborn Objects system to create a line chart with multiple lines:<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/02\/simple-seaborn-lineplot_multiple-lines.png\")
<\/p>\nPersonally, I think that the Seaborn Objects system is great for this.<\/p>\n
Although you can create simple charts with traditional Seaborn and Matplotlib functions, the Seaborn Objects system is much more flexible. It gives you a lot of control over your plots, with very simple syntax.<\/p>\n
With that being said, let’s look at the syntax for creating a line chart with the Seaborn Objects system.<\/p>\n
<\/a><\/p>\n
The Syntax for a Seaborn Lineplot<\/h2>\n
Here, I’ll show you the syntax for how to create a lineplot with the Seaborn objects system.<\/p>\n
To be clear: this is a new way to create a Seaborn lineplot, as of 2022. If you want a high-level overview of the Seaborn Objects system, you can read our tutorial about the Seaborn Objects API<\/a>.<\/p>\n
The older way to create a lineplot was with the sns.lineplot function. Review that tutorial for the syntax of sns.lineplot<\/a>.<\/p>\n
A quick note: import Seaborn Objects<\/h4>\n
Before we look at the syntax, I want to remind you that to use the Seaborn Objects package, we need to import it first.<\/p>\n
And exactly how<\/em> we import it will change the syntax slightly.<\/p>\n
The common way to import Seaborn Objects is like this:<\/p>\n
\r\nimport seaborn.objects as so\r\n<\/pre>\n
By importing Seaborn Objects like this, we can call the Seaborn Objects functions with the alias
so<\/code>.<\/p>\nSeaborn Lineplot syntax<\/h3>\n
Ok. Now, let’s look at the syntax to make a Seaborn lineplot with Seaborn Objects.<\/p>\n
We initialize the plot by calling
so.Plot()<\/code>. Inside the call to the Plot function, there are a few parameters that we use to specify the dataset, and the variable mappings (i.e., which variable to put on the x and y axes).<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/01\/seaborn-lineplot-syntax_seaborn-objects.png\")
<\/p>\nWe also need to call the
.add()<\/code> method, which tells Seaborn what type of “mark” to draw. To draw a lineplot, we need to callso.Line()<\/code> inside of the.add()<\/code> method.<\/p>\nThe parameters of for a Seaborn Lineplot<\/h3>\n
In the syntax image above, I noted several parameters that we typically need when we make a lineplot with the Seaborn Objects interface. There are also a few others.<\/p>\n
The commonly used parameters that I think you should know are:<\/p>\n
- \n
data<\/code><\/li>\nx<\/code><\/li>\ny<\/code><\/li>\ncolor<\/code><\/li>\ngroup<\/code><\/li>\n<\/ul>\nLet’s look at these one at a time.<\/p>\n
data<\/code><\/h6>\nThe
data<\/code> parameter specifies the dataframe with the data that you want to visualize.<\/p>\nTechnically, this parameter is optional.<\/p>\n
That’s because we can plot data in a dataframe, in which case we’ll use the
data<\/code> parameter.<\/p>\nBut we can also plot data that’s in Numpy arrays. If you’re plotting Numpy arrays, you probably won’t need this paramter.<\/p>\n
So if your data is in a dataframe, you can use the
data<\/code> parameter, and the argument to the parameter will be the name of the dataframe that holds your data.<\/p>\nAdditionally, there’s an important point about how you use this. When you pass the name of a dataframe to the
data<\/code> parameter, the name does not<\/em> need to be in quotes. (That’s in contrast to some of the arguments to other parameters.)<\/p>\nx<\/code><\/h6>\nThe x<\/em> parameter allows you to specify a variable that you want to map to the x-axis.<\/p>\n
If you’re plotting data in a dataframe (i.e., you used the
data<\/code> parameter as explained above), then the argument to this parameter will be the name of a column in that dataframe. If your argument to this parameter is a column in a dataframe, you’ll need to have the name of that column inside quotes.<\/p>\nAlternatively, you can also supply the name of a 1-dimensional Numpy array or array-like object to this parameter. If that’s the case, you will refrain from using quotes around the array name. They are not required for a Numpy array.<\/p>\n
Note that this parameter appears inside of the call to
so.Plot()<\/code>.<\/p>\ny<\/code><\/h6>\nThe y<\/em> parameter allows you to specify a variable that you want to map to the y-axis.<\/p>\n
Like the
x<\/code> parameter, if you’re plotting data in a dataframe (i.e., you used thedata<\/code> parameter as explained above), then the argument to they<\/code> parameter will be the name of a column in that dataframe. In this case, the name of that column needs to be inside quotes.<\/p>\nAlternatively, you can also supply the name of a 1-dimensional Numpy array or array-like object to this parameter. In that case, quotes will be unnecessary.<\/p>\n
Note that this parameter appears inside of the call to
so.Plot()<\/code>.<\/p>\ncolor<\/code><\/h6>\nThe
color<\/code> parameter manipulates the color of the line or lines that appear in the plot.<\/p>\nNote that you can use this parameter inside of the
so.Plot()<\/code> function, but you can also use it inside of the call toso.Line()<\/code>. How and where you use this parameter can cause subtle changes to the plot.<\/p>\nIf you use this parameter inside of
so.Plot()<\/code>, you can supply the name of a variable or dataframe column. Most commonly, the argument will be categorical data, and the different categories will become different lines in the plot, with different colors. I’ll show you an example of this in the examples section<\/a>.<\/p>\nYou can also use this parameter inside of
so.Line()<\/code>, which will enable you to specify a specific color for the line in your plot. For example, you can use this code to set the color of the line or lines to red:<\/p>\n\r\nso.Line(color = 'red') \r\n<\/pre>\n
Remember though, the call to so.Line() appears inside of the .
add()<\/code> method.<\/p>\nIf this feels confusing, don’t worry. I’ll show you an example in the examples section<\/a>.<\/p>\n
group<\/code><\/h6>\nThe
group<\/code> parameter enables you to create a line chart with multiple lines.<\/p>\nSo in some ways, it’s similar to the
color<\/code> parameter. <\/p>\nBut whereas the
color<\/code> parameter creates a lineplot with lines that have different colors …<\/p>\nThe
group<\/code> parameter creates a lineplot where all of the lines have thesame<\/code> color.<\/p>\nSo typically, the argument to this parameter will be a variable or column name that contains categorical data.<\/p>\n
<\/a><\/p>\n
Examples: How to make Line Charts in Python using Seaborn<\/h2>\n
Now that you’ve learned how the syntax works, let’s look at some examples of how to create a Seaborn lineplot with the Seaborn Objects interface.<\/p>\n
The links seen here will take you to each specific example, if you need something specific.<\/p>\n
Examples:<\/strong><\/p>\n
- \n
- Create a Simple Line Chart with One line<\/a><\/li>\n
- Change the Color of the Line (e.g. change the color to ‘red’)<\/a><\/li>\n
- Create a Line Chart with Multiple Lines (different colors)<\/a><\/li>\n<\/ul>\n
Having said that, there is some code that you’ll need to run before the examples will work.<\/p>\n
Run this code first<\/h4>\n
Before you run these examples, you’ll need to import some packages and get the data that we’ll work with.<\/p>\n
Import Pacakges<\/h5>\n
First, we need to import the Seaborn Objects subpackage, and also the Pandas package.<\/p>\n
You can do that by running the following code:<\/p>\n
\r\nimport seaborn.objects as so\r\nimport pandas as pd\r\n<\/pre>\n
Remember: when we import
seaborn.objects<\/code> with the aliasso<\/code>, we can useso<\/code> as a prefix when we call the Seaborn Objects functions. <\/p>\n<\/a><\/p>\n
Get dataset<\/h5>\n
Next, we need to get the data that we’ll be working iwth.<\/p>\n
In these examples, we’ll work with some time-series stock data. Specifically, data about Amazon and Google stock.<\/p>\n
To get this data, we’ll use the Pandas
read_csv<\/code> function. We’ll read data that exists at a URL, andread_csv<\/code> will import it as a dataframe.<\/p>\nWe’ll also use
pd.to_datetime()<\/code> to transform thedate<\/code> column to a proper datetime.<\/p>\n\r\nstocks = pd.read_csv(\"https:\/\/www.sharpsightlabs.com\/datasets\/amzn_goog_2000-01-01_to_2020-12-05.csv\")\r\nstocks.date = pd.to_datetime(stocks.date)\r\n<\/pre>\n
And now, let’s print out the data, so you can see what’s in it:<\/p>\n
\r\nprint(stocks)\r\n<\/pre>\n
OUT:<\/p>\n
\r\n date open high ... adj_close volume stock\r\n0 2000-01-03 81.500000 89.562500 ... 89.375000 16117600 amzn\r\n1 2000-01-04 85.375000 91.500000 ... 81.937500 17487400 amzn\r\n2 2000-01-05 70.500000 75.125000 ... 69.750000 38457400 amzn\r\n3 2000-01-06 71.312500 72.687500 ... 65.562500 18752000 amzn\r\n4 2000-01-07 67.000000 70.500000 ... 69.562500 10505400 amzn\r\n ... ... ... ... ... ... ...\r\n9364 2020-11-30 1781.183960 1788.064941 ... 1760.739990 1823800 goog\r\n9365 2020-12-01 1774.369995 1824.829956 ... 1798.099976 1739000 goog\r\n9366 2020-12-02 1798.099976 1835.650024 ... 1827.949951 1222000 goog\r\n9367 2020-12-03 1824.010010 1847.199951 ... 1826.770020 1227300 goog\r\n9368 2020-12-04 1824.520020 1833.160034 ... 1827.989990 1376100 goog\r\n\r\n[9369 rows x 8 columns]\r\n<\/pre>\n
You’ll notice that the
stock<\/code> variable contains the ticker symbol for the two companies that are in the dataset (amzn<\/code> for Amazon andgoog<\/code> for Google).<\/p>\nYou can check the unique values of the
stock<\/code> column as follows:<\/p>\n\r\npd.unique(stocks.stock)\r\n<\/pre>\n
OUT:<\/p>\n
\r\narray(['amzn', 'goog'], dtype=object)\r\n<\/pre>\n
The data also contains a
date<\/code> variable, as well as open and close prices.<\/p>\nWe’ll be able to plot these data as time series, using a line chart.<\/p>\n
<\/a><\/p>\n
EXAMPLE 1: Create a Simple Line Chart with One line<\/h3>\n
First, we’re going to create a line chart that has only a single line.<\/p>\n
This will be a simpler case, so it will be easier to understand.<\/p>\n
To do this though, we’ll first need to create a subset of our stock data.<\/p>\n
Create data subset of Amazon data<\/h5>\n
Here, we’ll create a subset of our dataframe that contains only Amazon data.<\/p>\n
To do this, we’ll take our
stock<\/code> dataframe and use the Pandas query method<\/a> to subset wherestock == 'amzn'<\/code>.<\/p>\n\r\namazon_stock = stocks.query(\"stock == 'amzn'\")\r\n<\/pre>\n
If you print this data out, or examine the unique values, you’ll see that
amazon_stock<\/code> only contains stock data for Amazon.<\/p>\nCreate Line Plot<\/h5>\n
Now, we can create our line plot.<\/p>\n
I’ll show you the code first, and then I’ll explain.<\/p>\n
\r\n(so.Plot(data = amazon_stock\r\n ,x = 'date'\r\n ,y = 'close'\r\n )\r\n .add(so.Line())\r\n )\r\n<\/pre>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/01\/seaborn-objects-lineplot_simple-lineplot.png\")
<\/p>\nExplanation<\/h5>\n
If you’re used to the “old” Seaborn system this might seem confusing.<\/p>\n
But, once you understand how it works, you’ll realize that it really makes a lot of sense.<\/p>\n
We use the
so.Plot()<\/code> function to initialize plotting.<\/p>\nInside the
Plot<\/code> function, we use thedata<\/code> parameter to specify the dataframe (i.e.,amazon_stock<\/code>). Then we’re using thex<\/code> andy<\/code> parameters to map thedate<\/code> column in the dataframe to the x-axis, and map theclose<\/code> column to the y-axis.<\/p>\nThe
.add()<\/code> method allows us to add a mark type.<\/p>\nIn this case, because we want to create a line chart, we’re going to add a “line” mark. To do this, we use
so.Line()<\/code>.<\/p>\nSo do you understand how this works?<\/p>\n
We …<\/p>\n
- \n
- initialize plotting<\/li>\n
- specify the dataframe<\/li>\n
- map columns from the dataframe to the aesthetic parameters<\/li>\n
- “add” a mark type<\/li>\n<\/ul>\n
It’s different than the single-function way of creating a lineplot with sns.lineplot()<\/a>.<\/p>\n
But it’s actually much more flexible.<\/p>\n
(To review how the Seaborn Objects system works, you can read our tutorial on the Seaborn Objects API<\/a>.)<\/p>\n
<\/a><\/p>\n
EXAMPLE 2: Change the Color of the Line<\/h3>\n
Next, we’re going to modify the chart that we created in example 1<\/a>, and change the color of the line.<\/p>\n
You’ll notice that by default, the color of the line is blue.<\/p>\n
Here, we’ll change it to red.<\/p>\n
In this example, we’ll reuse the
amazon_stock<\/code> dataset that we created in example 1. So if you need it, you can get the code to create it there<\/a>.<\/p>\nNow, let’s look at the code to create our line chart with a red line:<\/p>\n
\r\n(so.Plot(data = amazon_stock\r\n ,x = 'date'\r\n ,y = 'close'\r\n )\r\n .add(so.Line(color = 'red'))\r\n)\r\n<\/pre>\n
OUT:<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/01\/seaborn-objects-lineplot_red-line.png\")
<\/p>\nExplanation<\/h5>\n
Notice that the code for this example is almost identical to the code for example 1.<\/p>\n
The only difference is that we used the code
color = 'red'<\/code> inside of the call toso.Line()<\/code>. <\/p>\nSyntactically,
so.Line()<\/code>, and the parameters inside<\/em> of that function, control the properties of the line marks that we’re drawing. And thecolor<\/code> parameter obviously controls the color of the line marks that we’re drawing.<\/p>\nSo by setting
color = 'red'<\/code>, we’re telling the Seaborn Objects system to change the color of the line to red.<\/p>\nNote also that you can use any “named color” that Python recognizes. So you can try other colors like ‘navy’, ‘green’, ‘darkred’, or one of the others.<\/p>\n
Hexidecimal colors will also work. Those can be a little more complicated though, so I’ll refrain from explaining them here.<\/p>\n
<\/a><\/p>\n
EXAMPLE 3: Create a Line Chart with Multiple Lines (different colors)<\/h3>\n
Now, we’ll use the Seaborn Objects API to create a line chart with Multiple lines.<\/p>\n
In this example, we’ll use the
stocks<\/code> that we retrieved above<\/a>.<\/p>\nLet’s run the code to create the line plot, and then I’ll explain:<\/p>\n
\r\n(so.Plot(data = stocks\r\n ,x = 'date'\r\n ,y = 'close'\r\n ,color = 'stock'\r\n )\r\n .add(so.Line())\r\n)\r\n<\/pre>\n
OUT:<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/01\/seaborn-objects-lineplot_multi-line.png\")
<\/p>\nExplanation<\/h5>\n
You’ll notice that this is almost identical to the previous examples. There are only a few differences<\/p>\n
In this case, we are using a different dataframe, that has data for two socks:
amzn<\/code> andgoog<\/code>. We’re specifying the dataframe withdata = stocks<\/code>.<\/p>\nLike the previous examples, we’re setting
x = 'date'<\/code> andy = 'close'<\/code> to map thedate<\/code> column to the x-axis and theclose<\/code> column to the y-axis.<\/p>\nWe’re also using
.add(so.Line())<\/code> to specify that we want to add lines to the plot. <\/p>\nThe critical difference is that we’re setting
color = 'stock'<\/code>. This code maps the color of the lines to the values of thestock<\/code> column. Because the stock column contains categorical data with two values, this has the effect of creating a line chart with two lines<\/em> … one for each category.<\/p>\nIt’s pretty simple, once you know how the Seaborn objects system works<\/a>.<\/p>\n
<\/a><\/p>\n
Frequently asked questions about Seaborn Lineplots<\/h2>\n
Ok. Now that we’ve looked at some examples of Seaborn line charts, let me address a common question.<\/p>\n
Frequently asked questions:<\/strong><\/p>\n
- \n
- Is a Seaborn line chart better than a Matplotlib line chart or a Plotly line chart?<\/li>\n<\/ul>\n
<\/a><\/p>\n
Is a Seaborn line chart better than a Matplotlib line chart or a Plotly line chart?<\/h3>\n
The short answer is: yes.<\/p>\n
For a long time, data visualization in Python has been a mixed bag. Matplotlib was good for some things. Seaborn was good for others. And more recently, Plotly also had it’s uses.<\/p>\n
But with the release of Seaborn version 0.12.0, which contains the new Seaborn Objects API, I will probably be recommending Seaborn for most data visualization tasks.<\/p>\n
For very simple charts, like simple line charts, you can probably use Matplotlib or the earlier Seaborn functions.<\/p>\n
But the new Seaborn Objects API is superior in many ways. It’s easier to use, easier to modify. And it makes it easier to create more complex charts and graphs.<\/p>\n
If you’re doing data science and data visualization in Python, I strongly recommend that you use the new Seaborn Objects syntax.<\/p>\n
Leave your other questions in the comments below<\/h5>\n
Do you still have questions about Seaborn lineplots?<\/p>\n
If so, just leave your questions in the comments section below.<\/p>\n
If you want to master Seaborn, join our course<\/h2>\n
In this blog post, I’ve shown you how to create a Seaborn lineplot in Python. But if you need to visualize your Python data, there’s a lot more to learn.<\/p>\n
That said, if you’re serious about learning and mastering data visualization in Python, you should join our premium online course, Seaborn Mastery<\/a>.<\/p>\n
Seaborn Mastery is our online course that will teach you everything you need to know about data visualization with the Seaborn package.<\/p>\n
Inside the course, you’ll learn:<\/p>\n
- \n
- how to create essential plots like bar charts, line charts, scatterplots, and more<\/li>\n
- techniques for creating multivariate data visualization<\/li>\n
- how to add titles and annotations to your plots<\/li>\n
- how to “tell stories with data”<\/li>\n
- learn “how to think” about visualization<\/li>\n
- and much more …<\/li>\n<\/ul>\n
Additionally, when you enroll, you’ll get access to our unique practice system that will enable you to memorize all of the syntax you learn. If you practice like we show you, you’ll memorize Seaborn syntax and become “fluent” in writing data visualization.<\/p>\n
You can find out more here:<\/p>\n
\nLearn More About Seaborn Mastery<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
In this tutorial, I’ll show you how to create a Seaborn lineplot with the Seaborn Objects interface. So this tutorial will show you the syntax for building a lineplot with the Seaborn objects system, and it will show you step-by-step examples. If you need something specific, just click on any of the links below. Each … Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":5722,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_et_pb_use_builder":"","_et_pb_old_content":"","_et_gb_content_width":"","om_disable_all_campaigns":false,"footnotes":""},"categories":[58,24,74],"tags":[],"publishpress_future_action":{"enabled":false,"date":"2024-05-04 21:26:51","action":"change-status","newStatus":"draft","terms":[],"taxonomy":"category"},"_links":{"self":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/posts\/5684"}],"collection":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/comments?post=5684"}],"version-history":[{"count":0,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/posts\/5684\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/media\/5722"}],"wp:attachment":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/media?parent=5684"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/categories?post=5684"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/tags?post=5684"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
- Is a Seaborn line chart better than a Matplotlib line chart or a Plotly line chart?<\/li>\n<\/ul>\n
- Change the Color of the Line (e.g. change the color to ‘red’)<\/a><\/li>\n
- Syntax<\/a><\/li>\n