Preparation

We’ll start by defining some dummy data for our chart by leveraging the numpy library.

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(10)

x = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday']
y = np.random.randint(75,100,5)

Python horizontal line plotting using Matplotlib

We’ll first use Matplotlib to render our plot:

fig, ax= plt.subplots(figsize=(9,5))
ax.bar(x, height=y);

# Now we'll use the plt.axhline method to render the horizontal line at y=81

fig, ax= plt.subplots(figsize=(9,5))

ax.bar(x, height=y);
ax.axhline(y=81);

Here’s the result:

Customizing the Matplotlib axhline example

We’ll customize the line style by defining custom color, marker style, line style and width as shown below:

fig, ax= plt.subplots(figsize=(9,5))

ax.bar(x, height=y);
ax.axhline(y=81, color='green', marker='o', linestyle='--', linewidth = 5);

Plotting multiple lines

To add multiple lines to the chart, we’ll simply invoke axhline as needed.

fig, ax= plt.subplots(figsize=(9,5))

ax.bar(x, height=y);
ax.axhline(y=81, color='green', marker='o', linestyle='--', linewidth = 5);
ax.axhline(y=61, color='red', marker='o', linestyle='--', linewidth = 5);

Here’s our chart:

Drawing grid lines

If we want to easily draw gridlines in the background of our chart we can call plt.grid method

ax.grid()

And here’s our chart

Note: if you prefer the grid line to be displayed behind the chart, just use the zorder parameter.

Here’s the example:

fig, ax= plt.subplots(figsize=(9,5))

ax.bar(x, height=y, zorder=10);
ax.grid(zorder=0)

Vertical lines plotting will be covered in our next tutorial.

The post Plot horizontal lines in Matplotlib and Seaborn with Python first appeared on Data for Everybody.

Step 1: Import thew example dataset

#Python3

import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt
sns.set_style('whitegrid')

# Read the dataset into a Pandas DataFrame
deliveries = pd.read_csv('../../data/deliveries.csv')

Step 2: Create a Seaborn Countplot chart

We’ll start by rendering the countplot:

# define the figure and plot; modify the countplot figure size
countplt, ax = plt.subplots(figsize = (10,7))
ax =sns.countplot(x = 'day', data=deliveries)

Note: Use the figsize parameter to control the countplot proportions, width and height of our figure. Here’s a more detailed post and information on customizing Seaborn plot figsize.

Step 2: Associate a custom Seaborn palette

We can easily associate a predefined Seaborn palette to our plot.

# set countplot palette
ax =sns.countplot(x = 'day', data=deliveries, order = day_order, palette='pastel' )

Step 3: Add titles to the plot and axes

Our chart doesn’t make much sense without titles. We’ll use the plt.set_title and plt.set_xlabel methods to add titles to our plot.

# Chart and axes titles
ax.set_title('Daily Deliveries',fontsize = 18, fontweight='bold' )
ax.set_xlabel('Day', fontsize = 15)
ax.set_ylabel('Delivery count', fontsize = 15)
countplt

Step 4: order of x-axis labels in Countplots

As you can see above, the current order of the x-axis ticks doesn’t make much sense. Let’s modify that.

# change order x axis + change pallete
day_order = ['SUN','MON','TUE','WED','THU','FRI','SAT']
countplt, ax = plt.subplots(figsize = (10,7))
ax =sns.countplot(x = 'day', data=deliveries, order = day_order, palette='pastel' )

Let’s take a look at our chart.

Step 5: Show count in Seaborn countplots

A nice addition to our chart would be the ability to show the value count for every bar.

Here’s a simple code that uses plt.text() to annotate the count values on top of our plot.

# show count (+ annotate)
for rect in ax.patches:
    ax.text (rect.get_x() + rect.get_width()  / 2,rect.get_height()+ 0.75,rect.get_height(),horizontalalignment='center', fontsize = 11)
countplt

Looking good:

Step 6: Multiple categorical columns in sns countplot

We now want to show the usage of the hue parameter of sns.countplot() to achieve a categorical drill down of our delivery data.

# categorical countplot - show multiple columns
countplt, ax = plt.subplots(figsize = (10,7))
ax =sns.countplot(x = 'day', data=deliveries, order = day_order, palette='pastel', hue='time')
ax.set_title('Daily Deliveries',fontsize = 18, fontweight='bold' )
ax.set_xlabel('Day', fontsize = 15)
ax.set_ylabel('Delivery count', fontsize = 15)
for rect in ax.patches:
    ax.text (rect.get_x() + rect.get_width()  / 2,rect.get_height()+ 0.25,rect.get_height(),horizontalalignment='center', fontsize = 9)

Let’s take a look:

Step 7: Add the legend to the countplot

As can be seen above, the plot legend is overlapping with the top right of the chart. We would like to place the legend outside the countplot. We’ll use the bbox_to_anchor parameter to define a bounding box for the chart legend.

#countplot legend outside the chart
ax.legend(fontsize = 12, \
               bbox_to_anchor= (1.01, 1), \
               title="Time", \
               title_fontsize = 15);
countplt

Here’s the result:

Note: For more information about chart legend customization, check out our comprehensive tutorial on Seaborn legends.

Further learning:

• How to set axes labels & limits in a Seaborn plot?

The post Create a Seaborn countplot using Python: a step by step example first appeared on Data for Everybody.

Step 1: Prepare your data for visualization

We’ll start by defining a simple dataset for this example.

# Python3

# import pandas and matplotlib
import pandas as pd
import matplotlib.pyplot as plt

# Create Dataframe dataframe 
revenue = pd.DataFrame({"city":['Chicago', 'Boca Raton', 'Miami','Omaha']* 2,
                    "sales": [3568, 2367, 2152, 3027, 3695, 2495, 4134, 2162]})
 
# Grouping the data 
rev_by_city = revenue.groupby('city')['sales'].sum()

We got a Pandas Series that we’ll quickly visualize using Pandas & Matplotlib

Step 2: Draw your Matplotlib plot

Let’s set a very simple plot using Matplotlib:

x = rev_by_city.index
y = rev_by_city.values

fig, ax = plt.subplots(dpi = 147)
ax.bar(x,y, color='green');

We got a very simple chart.

Note: We could have got a somewhat similar output using the Pandas library only:

rev_by_city.plot(kind='bar', color='green');

Step 3: Matplotlib chart custom titles

Let’s run the get_title() method on our plot:

ax.get_title()

As expected, the result is an empty string.

Define plot titles

The plt.set_title() method is self explanatory. It allows to define a title for your chart.

ax.set_title('Sales by City');
fig

Customize Matplotlib title fonts size and color

Let’s quickly define a title and customize the font size, weight and color.

ax.set_title('Sales by City', fontsize=15, color= 'blue', fontweight='bold');
fig

Here’s the result:

Set Matplotlib title position

By default the title is aligned to the center of the plot. Using the loc parameter, you are able to left and right align it.

In this case, we’ll left align the title:

fig, ax = plt.subplots(dpi = 147)
ax.bar(x,y, color='green');
ax.set_title('Sales by City', fontsize=15, color= 'blue', fontweight='bold',loc='left');

We can also use the y parameter to determine the margin from the title to the chart

fig, ax = plt.subplots(dpi = 147)
ax.bar(x,y, color='green');
ax.set_title('Sales by City', fontsize=15, color= 'blue', fontweight='bold', y= 1.1);

Matplotlib title inside plot

What if we want to place the title so it will overlap with the inside part of the plot figure? That’s possible by setting the y parameter to a negative figure, in our case -0.9. We also used the pad parameter to increase the padding from the figure border:

fig, ax = plt.subplots(dpi = 147)
ax.bar(x,y, color='green');
ax.set_title('Sales by City', fontsize=15, color= 'blue', fontweight='bold', loc='left', y=0.9,  pad= -10);

If you are using Seaborn, you might want to look into a similar tutorial on how to customize Seaborn titles.

The post How to customize Matplotlib plot titles color, position and fonts? first appeared on Data for Everybody.

Most probably you’ll be acquiring your data from an API, database, text or comma separated value file. But in this example we’ll use a simple dataframe that we’ll define manually out of a dictionary.

# Python3
import pandas as pd
targets = pd.DataFrame({ "manager": ["Johns;Tim ", "Mcgregor; Dave", "DeRocca; Leo", "Haze; Jim"] ,
                     "target": [42000, 85000, 45000, 33000]})

Let’s look at the data:

targets.head()

Split columns in Pandas dataframes

Splitting into multiple columns with str.split()

We would like to split the manager column into two. As you can see the name and family name are separated by a semi-colon.

manager = targets['manager']
targets[['last_name','first_name']] =  manager.str.split(";", n=1, expand=True)
targets

Explanation:

1. We user str.split() method to first convert the Series to a string.
2. The str.split() method receives a couple of parameters:
   • First (‘;’) is the split character, in this case a semi-colon.
   • Second (N=1) is the number of splits we would like to define for the string. If you would to divide the column text into more than two columns, set your N parameter accordingly.
   • Expand=True has to be specified, as otherwise the string will not be divided into different columns.
3. Once split the strings are kept in two columns we’ll add to the dataframe: ‘last_name’,’first_name’

Here’s our DataFrame:

Dividing a DataFrame column by comma

If your separator is a comma, then we just need to adjust the separator parameter of the split method.

targets[['last_name','first_name']] =  manager.str.split(",", n=1, expand=True)

Export DataFrame Column values to list

Couple of readers asked me about this topic. We have a detailed post on this topic. Look here.

Drop a redundant Pandas column

if you would like to keep only one of the new columns we just created, you can use the following code:

targets.drop('first_name', axis=1)

More on removing Pandas dataframe columns can be found here.

Common Questions

How do I split a column when values have inconsistent delimiters?

Pass a regex pattern to str.split() to handle multiple delimiters simultaneously. For instance, df['col'].str.split(r'[;,|]', expand=True) splits on semicolons, commas, or pipes in a single operation. Set expand=True to place each piece into its own column automatically. When the split produces fewer pieces for some rows, Pandas fills the missing columns with NaN. You can then insert an empty column into your dataframe as a placeholder before merging the split results back in, giving you full control over column ordering.

How do I keep the original column after splitting it into multiple new columns?

The str.split(expand=True) method returns a new dataframe and does not modify the original column. Assign the result to new column names like df[['first', 'last']] = df['name'].str.split(' ', n=1, expand=True), and the source column remains intact. If you need to build up columns from list-type data stored in cells, you can append Python list values as new columns using similar assignment patterns. Setting the n parameter limits the number of splits, which is useful when only the first delimiter matters.

Why does str.split() return NaN for some rows?

This happens when a cell contains a genuine NaN value rather than a string. The str.split() method skips non-string entries and returns NaN for those rows. Clean your data first with df['col'].fillna('') to convert missing values to empty strings before splitting. Alternatively, use df.dropna(subset=['col']) to remove rows with missing data entirely if they are not relevant to your analysis.

The post Pandas: split one column into two or multiple columns in Python first appeared on Data for Everybody.

For convenience, I’ll use Seaborn in this example, but the methods we’ll use in order to resize the axis limits are first and foremost part of Matplotlib and can be used on every pyplot chart.

Use Seaborn xlim and set_ylim to set axis limits

Consider the following code that will render the simple scatter plot we see below.

fig, scatter = plt.subplots(figsize = (10,6), dpi = 100)
scatter = sns.scatterplot(x = 'mass', y ='distance', data=data);

Seems that except a few outliers, we can probably focus our data analysis on the bottom left part of our sns.scatter plot chart.

If that is the case, we can go ahead and redefine new limits for both axes in our plot using the following script.

# with xlim/ylim
fig, scatter = plt.subplots(figsize = (10,6), dpi = 100)
scatter = sns.scatterplot(x = 'mass', y ='distance', data=data)
scatter.set_xlim(left=0, right=6)
scatter.set_ylim(bottom=0, top=200);

Here’s our chart, note the new range limits for both the X and y axes. Note that for better clarity you might want to resize your Seaborn plot as needed.

Important Note: Although we used an sns.scatterplot as an example, all the above works on the other Seaborn charts: boxplot, barplot, catplot, lineplot etc’

Follow up questions? Happy to answer your comments.

The post Seaborn and Matplotlib axis limits with xlim and ylim first appeared on Data for Everybody.

Consider the following code snippet:

# import the pandas package
import pandas as pd

# initialize the DataFrame
data = pd.DataFrame({ "manager": ["Debbie", "Daisy", "Dorothy", "Tim"] * 2,
                     "target": [32000, 45000, 18000, 20000] * 2})
data.head()

Here’s our DataFrame header:

Using pd.DataFrame.tolist() to write column to a list

Here’s the Python code you’ll need to export column values to a Python list:

# Dataframe Column values to Python list
data['manager'].values.tolist()

Here’s the list object we’ll get:

[‘Debbie’, ‘Daisy’, ‘Dorothy’, ‘Tim’, ‘Debbie’, ‘Daisy’, ‘Dorothy’, ‘Tim’]

Pandas column index to list

data['manager'].index.tolist()

[0, 1, 2, 3, 4, 5, 6, 7]

Unique column values to list

As shown above, we were able to export the values to a list. The list however had duplicated entries. Here’s how to ensure that the list has only unique values:

# Export unique column values only
data['manager'].unique().tolist()

[‘Debbie’, ‘Daisy’, ‘Dorothy’, ‘Tim’]

Unique list values using set

Other way to ensure uniqueness in the list is to convert it to a set to get rid of duplicated values.

unique_managers = set(data['manager'].values.tolist())
list(unique_managers)

tolist() with condition

What if we just want to write values that satisfy a condition?

# Condition: Only managers which name starts with the letter D
cond = data['manager'].str.startswith('D')
data[cond]['manager'].unique().tolist()

Here’s the result:

[‘Debbie’, ‘Daisy’, ‘Dorothy’]

Series values to List

For completeness, here’s a short snippet for writing Series values to a list (you can find a more complete example here)

manager_series = pd.Series(["Debbie", "Kim", "Dorothy", "Tim"])
manager_series.to_list()

Going Further

Can I export a DataFrame index to a list the same way as a column?

The approach is nearly identical. Use df.index.tolist() to convert the index into a standard Python list. This works for default integer indices, named indices, and DatetimeIndex objects alike. If your DataFrame uses a MultiIndex, tolist() returns a list of tuples representing each level combination. For a deeper walkthrough of index conversion scenarios, including exporting to NumPy arrays, see the guide on converting a Pandas index to a list or array. The method is consistent across Pandas versions and handles missing index values gracefully by preserving NaN entries in the output list.

How do I export only unique column values or filter rows before converting?

Chain .unique().tolist() on a column to extract deduplicated values — for example, df['city'].unique().tolist() returns distinct city names in order of first appearance. For conditional exports, apply a boolean mask first: df[df['sales'] > 100]['product'].tolist() gives you product names only where sales exceed 100. When filtering by specific row values across multiple conditions, techniques for finding DataFrame rows by value pair well with tolist() to build precise, filtered lists from your data.

What is the performance difference between tolist() and list() on a DataFrame column?

Both df['col'].tolist() and list(df['col']) produce identical output, but tolist() is faster for large DataFrames because it operates directly on the underlying NumPy array without Python-level iteration. On a column with one million rows, tolist() typically runs two to three times faster. The difference becomes negligible below ten thousand rows. Also note that tolist() converts NumPy data types to native Python types automatically, which matters when serializing to JSON or passing values to libraries that reject NumPy scalars.

The post How to export a Python Dataframe column to a list? first appeared on Data for Everybody.

Let’s quickly start by creating some random data for this exercise:

import pandas as pd
import numpy as np # used for generating random data
np.random.seed(10)

date_range =  pd.date_range('2020-01-01','2020-11-01', freq ='MS')

raw_data = {'time': date_range, \
                     'sales': [x for x in np.random.randint(30, 100, \
                               len(date_range) )]}

# create dataframe from dictionary

sales = pd.DataFrame.from_dict(raw_data)

sales.head()

Here’s our dataframe header:

Using DataFrame.plot() to draw datetime charts in Pandas

Now that we have some data available, let’s take a look at how to quickly draw our plot using the DataFrame.plot() method that is readily made available in Pandas.

sales.plot(x= 'time', y= 'sales', kind='line');

This will render a simple line plot. Pandas took care of converting the datetime values of the ‘time’ column to months automatically.

And a bit more elaborated version:

sales.plot(x= 'time', 
           y= 'sales', 
           kind='line',
           figsize = (10,6), 
           title="Sales Over Time",
           grid=True , 
           style = 'r');

The post Pandas: how to plot timeseries based charts? first appeared on Data for Everybody.

I am getting started with using Matplotlib and Seaborn on a Jupyter notebook. Trying to show a simple scatter plot but nothing shows up. What do you think i am doing wrong so no chart is displayed ?

It’s a bit hard to help without the code sample, but here are a couple of pointers as well as a simple example that you can use to troubleshoot this.

Set %matplotlib inline

In order to plot directly into your Jupyter notebook, you need to set the following swtich a=fter importing Matplotlib.

import matplotlib.pyplot as plt
%matplotlib inline

Use pyplot.show() to display your charts

Here’s a code snippet that uses the built-in Seaborn planets dataset for simplicity.

import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline

my_data = sns.load_dataset ('planets')

sns.scatterplot(x = 'mass', y ='distance', data=my_data)
plt.show()

The plt.show method will display your scatter chart:

From here you can go ahead and customize your chart such as adding titles and legends.

Hopefully this helped answer your question. Feel free to leave us additional questions in the comments below.

The post Fix Seaborn and Matplotlib plots not showing in Jupyter first appeared on Data for Everybody.

Here’s a Python snippet that builds a simple Seaborn barplot (sns.barplot). I assume that you have already imported Matplotlib and / or Seaborn to your Jupyter notebook beforehand.

labels = ['Grocery deliveries', 'Gear deliveries', 'Food deliveries', 'Medicines deliveries']

fig, bar = plt.subplots()
bar = sns.barplot(data = deliveries, x = x, y = y, estimator = sum)
bar.set_ylabel('Tip', fontsize=14)
bar.set_xlabel('Type', fontsize=14)
bar.set_xticklabels(labels, fontsize=14);

Here’s the result:

The axes ticks xticklabels are overlapping and not readable.

Rotate Matplotlib and Seaborn tick labels

The solution is relatively simple. We need to use the rotation parameter that is available for the pyplot.xticklabels method. For eachset of tick labels, you’ll need to specify the required rotation angle in degrees.

bar.set_xticklabels(labels, fontsize=14, rotation=30);

You might want to use the ha parameter to horizontally align the label.

bar.set_xticklabels(labels, fontsize=14, rotation=30, ha= 'right');

Here’s the updated chart:

The procedure to rotate and align the y axes is similar – just use the pyplot.set_yticklabels() method instead.

Tip: as you see, the chart is still somewhat small and not readable enough. If that’s the case, you can increase your plot size with ease.

This procedure is identical for lineplots, boxplots, catplots and heatmaps.

The post Rotate axis tick labels in Seaborn and Matplotlib first appeared on Data for Everybody.

We’ll be using our deliveries dataset, which you can download from here.

Seaborn legends example

Consider the following script that renders a scatter plot from a Python DataFrame data.

# import required libraries
import seaborn as sns
import pandas as pd

sns.set_style('whitegrid')

# acquire the test data
deliveries = pd.read_csv('../data/del_tips.csv')

# define the axes content
x = deliveries['time_to_deliver']
y = deliveries['del_tip_amount']

#sns.scatterplot from DataFrame
fig, scatter = plt.subplots(figsize = (10,6), dpi = 100)
scatter = sns.scatterplot(x = x, y =y, data=deliveries, hue='type' )
scatter.set_title('Tip vs Delivery Speed', fontsize = 23, y =1.05);

We’ll get the following chart:

Hide the Seaborn legend

If you might want to remove your legend altogether, you need to use the legend=False switch.

scatter = sns.scatterplot(x = x, y =y, data=deliveries, hue='type', legend= False)

Seaborn will display the following warning: No handles with labels found to put in legend.

Change Seaborn legend location

Probably the most visible issue we have with our chart is the location of the legend. What if we want to display it outside the figure, so it doesn’t overlap with any observation we plot?

The bbox_to_anchor parameter allows us to pass an (x,y) tuple with the required offset. You might want to tweak it as per your needs.

scatter.legend(bbox_to_anchor= (1.03, 1) );

Note: We can also use the loc parameter to specify a location for the legend size on the the chart. I typically use loc= ‘upper right’.

Set legend font size

The second issue we recognize in our chart is that by default our legend fonts are too small for the figsize we set. We can fix it with ease:

#tweak the font heights in px
scatter.legend(fontsize = 15) 

Modify the Seaborn legend title

Next we would like to provide a meaningful title to our legend.

scatter.legend(title="Delivery Type");

Set the Legend background color

We can also modify the background color of our legend, as shown below:

scatter.legend(shadow = True, facecolor = 'grey')

Bringing all of it together

scatter.legend(fontsize = 15, \
               bbox_to_anchor= (1.03, 1), \
               title="Delivery Type", \
               title_fontsize = 18, \
               shadow = True, \
               facecolor = 'white');

Notes:

• There is more to customize for Seaborn legends (handlers, labels etc’). We’ll cover that in subsequent tutorials.
• Although written for the scatterplot, this tutorial is applicable for the different Seaborn charts for raw data, bi-variate / categorical analysis: catplot, plotbox, barplot, paiplots etc’.

The post How to change Seaborn legends font size, location and color? first appeared on Data for Everybody.