Data visualization is a crucial aspect of data analysis, enabling data scientists and analysts to interpret complex data sets and derive meaningful insights. Among the myriad of Python libraries available for data visualization, Leather stands out for its simplicity and efficiency. This article delves into the features, capabilities, and usage of the Leather library, providing a comprehensive guide for those looking to create quick and effective visualizations.

Introduction to Leather

Leather is a Python charting library designed for users who need to create charts quickly and are less concerned with achieving perfect aesthetics. It is particularly useful for generating basic, yet informative, visualizations without the overhead of more complex libraries. Leather is known for its rough and ready approach, making it an ideal choice for rapid prototyping and exploratory data analysis.

Key Features of Leather:

Leather offers several features that make it a valuable tool for data visualization:

• Simplicity: Leather is designed to be straightforward and easy to use, allowing users to create charts with minimal code.
• Versatility: It supports various data types and can produce charts in scalable vector graphics (SVG) format, ensuring high-quality output.
• Speed: Leather is optimized for speed, making it suitable for generating visualizations on-the-fly.
• Minimal Dependencies: The library has minimal dependencies, reducing the complexity of installation and usage.

Installing Leather

To get started with Leather, you need to install it via pip. Open your terminal or command prompt and run the following command:

pip install leather

Creating Basic Charts with Leather

Leather supports several types of charts, including bar charts, line charts, scatter plots, and more. Below are examples of how to create some of these charts using Leather.

1. Bar Chart

A bar chart represents the frequency of a category. Generally, there are two types of bar charts: the horizontal bar chart, also known as ‘Bars’ in this library, and the vertical bar chart, known as ‘Columns’. Now let’s first build a horizontal bar chart.

• To do this, we will first import all the necessary libraries, Import SVG and display from IPython to render and display the chart in a notebook or IPython environment.
• Use the Chart() function from the Leather library to create the chart and provide a title as a string.
• Use the add_bars() function to add the data to the chart by passing the variable name of the dataset.

import leather
from IPython.display import SVG, display

sales_data = [
    (230, 'Alex'),
    (150, 'Jordan'),
    (90, 'Taylor'),
    (310, 'Morgan'),
    (180, 'Chris'),
    (270, 'Pat'),
    (130, 'Sam'),
    (220, 'Jamie')
]

# Creating a bar chart
bar_chart = leather.Chart('Sales Units by Salesperson')
bar_chart.add_bars(sales_data)

# Saving the SVG file
bar_chart.to_svg('sales_units_bar_chart.svg')

# Displaying the SVG
display(SVG(bar_svg_file))

Output:

Now, let’s build the vertical bar chart. The only change is to use the add_columns() function instead of the add_bars() function to add data to the graph. Here’s how to do it:

import leather
from IPython.display import SVG, display

# New sales data for the vertical bar chart
sales_data_vertical = [
    ('Alex', 230),
    ('Jordan', 150),
    ('Taylor', 90),
    ('Morgan', 310),
    ('Chris', 180),
    ('Pat', 270),
    ('Sam', 130),
    ('Jamie', 220)
]

# Creating a vertical bar chart
vertical_bar_chart = leather.Chart('Sales Units by Salesperson (Vertical)')
vertical_bar_chart.add_columns(sales_data_vertical)

# Saving the SVG file
vertical_bar_chart.to_svg('vertical_bar_chart.svg')

# Displaying the SVG
display(SVG('vertical_bar_chart.svg'))

Output:

2. Scatter Plot

A scatter plot is a type of visualization that displays points or data with respect to an x and y axis. Each point represents the values of two variables. This plot is used to understand the correlations between two variables and to identify patterns such as clusters, trends, or outliers.

• Now let’s create this plot using Leather. As usual, first, we will import the necessary libraries.
• Then, we will create a dummy dataset with numerical values for both the x and y axes.
• Next, we will give the plot a title using the Chart() function.
• The main part involves adding our data to the plot using the add_dots() function to create the scatter plot.

Finally, to save and display the graph, we will use the to_svg() and display(SVG()) functions, just like before.

import leather
from IPython.display import display, SVG

data = [(0, 3), (4, 5), (7, 9), (8, 4), (2, 6), (5, 2), (9, 8)]

#Creating plot
chart = leather.Chart('Dots')
chart.add_dots(data)

#Saving plot
chart.to_svg('scatter_plot.svg')

#Displaying plot
display(SVG('scatter_plot.svg'))

Output:

3. Line Plot

A line plot is a variation of the scatter plot where each data point is connected by a straight line. It is used to analyze trends and changes in a dataset over time. This type of plot is commonly employed in finance and stock analysis.

• To build this plot, we need to import the required libraries and create a numerical dataset with two variables, as done previously.
• To add the data in a line form, we will use the add_line() function.
• With this, our line plot is ready. Finally, we will save the plot using to_svg() and display it using display(SVG()), as done previously.

import leather
from IPython.display import display, SVG

data = [(0, 3), (4, 5), (7, 9), (8, 4), (2, 6), (5, 2), (9, 8)]

#Creating plot
chart = leather.Chart('Lines')
chart.add_line(data)

#Saving plot
chart.to_svg('scatter_plot.svg')

#Displaying plot
display(SVG('scatter_plot.svg'))

Output:

Mixed Plot With Leather

We can also mix or integrate two different plots into a single plot. To do this we first will store our dummy data into two variables, then call plot functions like add_line() and add_dots() simultaneously.

import leather
from IPython.display import display, SVG

dot_data = [(0, 3), (4, 5), (7, 9), (8, 4), (2, 6), (5, 2), (9, 8)]
line_data = [(2, 3), (4, 2), (5, 9), (3, 4), (6, 6), (8, 2), (9, 1)]

#Creating plot
chart = leather.Chart('Lines and Dots Plot')
chart.add_dots(dot_data)
chart.add_line(line_data)

#Saving plot
chart.to_svg('plot.svg')

#Displaying plot
display(SVG('plot.svg'))

Output:

Mixed Plot With Leather

As you can see in the above plot, since we used two different datasets, we are getting legend values as ‘Unnamed series’ because we didn’t specify labels for them.

When combining different plots, it’s important to clearly label each plot to indicate what each specific series represents.

And we can achieve this, along with many other customizations, by using styling. Let’s get into it.

Customizing Charts With Leather

While Leather is designed for simplicity, it also offers some customization options to enhance the appearance of your charts.

1. Legends/Labels

To add labels or legends to our mixed plot, we need to use the name parameter for each plot. Here’s how to do it for the above plot:

chart.add_dots(dot_data, name='Dots')
chart.add_line(line_data, name='Lines')

Output:

2. Changing Plot Colors

You might have wondered why every plot we’ve built so far is red. This is because red is the default colour for all plots in Leather.

We need to use the fill_color parameter to change the colour when adding data to the plot. This feature is handy as it allows us to visualize data in the colour of our choice.

For this example, let’s take the first plot we built, which was a horizontal bar plot, and change the colour from red to black by adding this parameter. Here’s how to do it:

bar_chart.add_bars(sales_data, fill_color='black')

Output:

Changing Plot Colors

3. Creating dashed lines plot

As we can see in the line plot, it looks quite boring. Let’s make the lines dashed to improve its appearance.

To do this, we will use the stroke_dasharray parameter inside the add_line() function. Let’s edit our previous line plot and add this parameter.

chart.add_line(data, stroke_dasharray='2%')

Output:

Dashed lines plot

Advanced Usage With Leather’s Library

For more advanced usage, Leather can be integrated with other data manipulation libraries such as Pandas. This allows for seamless data processing and visualization.

Integrating with Pandas

Here’s an example of how to use Leather with Pandas to visualize a DataFrame:

import leather
import pandas as pd

data = {
    'Category': ['A', 'B', 'C'],
    'Values': [10, 20, 15]
}

df = pd.DataFrame(data)

# Create a chart from the DataFrame
chart = leather.Chart('Pandas Bar Chart')
chart.add_bars(df.values)
chart.to_svg('pandas_bar_chart.svg')

Output:

Integrating with Pandas

Conclusion

Leather is a powerful yet simple Python library for data visualization. Its ease of use, speed, and minimal dependencies make it an ideal choice for users who need to create charts quickly without worrying about perfect aesthetics. Whether you are a data scientist, analyst, or developer, Leather can help you visualize your data effectively and efficiently.

By integrating Leather with other data manipulation libraries like Pandas, you can streamline your data analysis workflow and create informative visualizations with minimal effort.