A Beginner's Guide to Data Visualization with Python
The World before the creation of Data Visualization
Before the development of Data Visualization tools, users would frequently analyze and visualize information using traditional methods such as spreadsheets, tables, and text-based reports. These methods had several limitations, such as:
Difficult to manually scan huge amounts of data, which would be time-consuming and error-prone.
Difficult to communicate complex data to others in a clear and easy-to-understand format.
Difficult to identify the correlation between different variables which can help predict the future outcome of certain variables.
Difficult to gain a deep understanding of the data, as it was presented in a raw and unprocessed format.
How Data Visualization overcomes these limitations?
With the invention of Data Visualization tools,
Made it easy to quickly identify patterns and trends in data.
Made it easy to communicate complex data in a clear and easy-to-understand format.
Made it easier to identify the correlation between different variables, and also to gain a deeper understanding of the data.
With this understanding now let us deep dive into the Data Visualization Tools.
Data Visualization tools help us to understand large and complex data sets by using visual elements like charts, graphs, and maps, and also make it possible to quickly identify patterns and trends that would be difficult to detect in raw data.
With the popularity of Python as a popular programming language for data analysis, there are several libraries available for building creative and informative visualizations.
In this beginner's guide, we'll cover some of the most popular libraries as well as approaches for creating informative plots, and also we will see how it makes a great choice for beginners to get started with Data Visualization.
Now, we have a basic understanding of Data Visualization and now let's discuss the libraries we will be using to create a visualization in Python.
Some of the most popular libraries for Data Visualization in Python are Matplotlib, Seaborn and Plotly.
Matplotlib is the most widely-used library and is a great choice for creating basic plots and charts.
Seaborn is built on top of Matplotlib and is designed for creating more complex and attractive visualizations.
Plotly is a library that allows you to create interactive plots and is a good choice if you want to create visualizations that can be explored and manipulated by the user.
Matplotlib
Before we can start creating visualizations in Matplotlib, we first need to install Matplotlib. The easiest way to do this is by using pip, the package installer for Python. Open a terminal and type in the following command:
pip install matplotlib
Once Matplotlib is installed, we can import it into our Python script using the following code:
from matplotlib import pyplot as plt
Following are the code snippets to create line, bar, pie, scatter plots and histogram using the matplotlib library.
Bar Chart
Bar charts are an effective way to visualize and compare categorical data. They are particularly useful for comparing the values of a single variable across different categories. In Matplotlib, we can create bar charts using the bar() or barh() function. The bar() function creates a vertical bar chart, while the barh() function creates a horizontal bar chart.
Here is an example of how to create a bar chart using Matplotlib:
from matplotlib import pyplot as plt
courses = ["Python", "Java", "C", "C++", "C#"]
sales = [50, 45, 30, 40, 43]
plt.bar(courses, sales, width=0.5)
plt.xlabel("Courses available")
plt.ylabel("No. of sales")
plt.title("Sales data")
plt.show()
Line Chart
Line charts are an effective way to visualize and compare continuous data over time. They are particularly useful for visualizing trends and changes in data over time. In Matplotlib, we can create line charts using the plot() function.
Here is an example of how to create a line chart using Matplotlib:
from matplotlib import pyplot as plt
mobile = [100000, 110000, 120000, 130000, 140000, 150000, 160000, 170000]
laptop = [50000, 61000, 72000, 73000, 75000, 77000, 78000, 79000]
smart_watch = [80000, 81000, 82000, 83000, 84000, 85000, 86000, 87000]
head_phone = [90000, 91000, 92000, 93000, 94000, 95000, 96000, 97000]
plt.plot(mobile, label='mobile')
plt.plot(laptop, label='laptop')
plt.plot(smart_watch, label='smart watch')
plt.plot(head_phone, label='head_phone')
plt.xlabel('Year')
plt.ylabel('No. of Sales')
plt.title('Gadget Sales')
plt.legend()
plt.show()
Pie Chart
Pie charts are an effective way to visualize the proportion of different categories in a dataset. They are particularly useful for visualizing data that can be divided into a small number of categories. In Matplotlib, we can create pie charts using the pie() function.
Here is an example of how to create a pie chart using Matplotlib:
from matplotlib import pyplot as plt
import numpy as np
x = np.array([2, 4, 3, 6, 7])
label = ['apple', 'orange', 'grape', 'cherry', 'papaya']
plt.pie(x, labels=label, autopct='%1.2f%%')
plt.legend(title='Fruits')
plt.show()
Scatter Plot
Scatter plots are an effective way to visualize the relationship between two variables in a dataset. They are particularly useful for visualizing data with a large number of points. In Matplotlib, we can create scatter plots using the scatter() function.
Here is an example of how to create a scatter plot using Matplotlib:
from matplotlib import pyplot as plt
import numpy as np
# Day one, the age and speed of 13 cars:
x = np.array([5,7,8,7,2,17,2,9,4,11,12,9,6])
y = np.array([99,86,87,88,111,86,103,87,94,78,77,85,86])
plt.scatter(x, y)
plt.scatter(x, y, marker='o')
# Day two, the age and speed of 15 cars:
x = np.array([2,2,8,1,15,8,12,9,7,3,11,4,7,14,12])
y = np.array([100,105,84,105,90,99,90,95,94,100,79,112,91,80,85])
plt.scatter(x, y, marker='*')
plt.title('Scatter Plot')
plt.xlabel('age')
plt.ylabel('speed')
plt.colorbar()
plt.show()
Histogram Plot
In addition to line plots, scatter plots, and bar plots, Matplotlib also allows us to create histograms. Histograms are useful for visualizing the distribution of a dataset. They are particularly useful for understanding the distribution of continuous variables, such as ages, heights or weights.
In Matplotlib, we can create histogram plots using the hist() function.
Here is an example of how to create a histogram plot using Matplotlib:
from matplotlib import pyplot as plt
ages = [10, 20, 42, 23, 12, 11, 34, 45, 21, 17, 46, 23, 33,
35, 34, 12, 16, 54, 31, 22, 23, 25, 24, 26, 29, 39,
40, 41]
plt.hist(ages,edgecolor="black")
plt.title("Age Group")
plt.xlabel("Ages")
plt.ylabel("Frequencies")
plt.show()
Seaborn
Now we will explore the seaborn library. In order to work with seaborn library first we need to install the package using the following command:
pip install seaborn
Once Seaborn is installed, we can import it into our Python script using the following code:
import seaborn as sns
Following are the code snippets to create line, bar, scatter plots and heat map using seaborn library.
Line Chart
In Seaborn, line plots can be used to visualize the trend of one or more variables over time or across categories. It can be created using the lineplot() function.
Here is an example of how to create a line plot using Seaborn:
import seaborn as sns
import matplotlib.pyplot as plt
# Loaded a 'tips' dataset from seaborn
tips = sns.load_dataset("tips")
# Create a line plot of the total bill by day of the week
sns.lineplot(x="day", y="total_bill", data=tips)
plt.title("Total Bill by Day of the Week")
plt.xlabel("Day of the Week")
plt.ylabel("Total Bill")
plt.show()
Bar Chart
In Seaborn, bar plots can be used to visualize the distribution of a categorical variable. It can be created using the countplot() function.
Here is an example of how to create a bar plot using Seaborn:
import seaborn as sns
import matplotlib.pyplot as plt
# Loaded a 'tips' dataset from seaborn
tips = sns.load_dataset("tips")
# Create a bar plot of the number of customers by day of the week
sns.countplot(x="day", data=tips)
plt.title("Number of Customers by Day of the Week")
plt.xlabel("Day of the Week")
plt.ylabel("Number of Customers")
plt.show()
Scatter Plot
In Seaborn, scatter plots can be used to visualize the relationship between two continuous variables. It can be created using the scatterplot() function.
Here is an example of how to create a scatter plot using Seaborn:
import seaborn as sns
import matplotlib.pyplot as plt
# Loaded a 'tips' dataset from seaborn
tips = sns.load_dataset("tips")
# Create a scatter plot of total bill vs. tip
sns.scatterplot(x="total_bill", y="tip", data=tips)
plt.title("Total Bill vs. Tip")
plt.xlabel("Total Bill")
plt.ylabel("Tip")
plt.show()
Heat Map
In Seaborn, heat maps can be used to visualize the relationship between two categorical variables and one continuous variable. It can be created using the heatmap() function.
Here is an example of how to create a heat map using Seaborn:
import seaborn as sns
import matplotlib.pyplot as plt
# Loaded a 'flights' dataset from seaborn
flights = sns.load_dataset("flights")
# Create a pivot table to aggregate the flight data
flights_pivot = flights.pivot("month", "year", "passengers")
# Create a heat map of the flight data
sns.heatmap(flights_pivot, cmap="plasma")
plt.title("Number of Passengers by Month and Year")
plt.show()
Plotly
Now we will explore the plotly library. In order to work with plotly library first we need to install the package using the following command:
pip install plotly
Once Plotly is installed, we can import it into our Python script using the following code:
import plotly.express as px
Following are the code snippets to create line, bar, and pie chart using plotly library.
Line Chart
import plotly.express as px
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
# Create the line chart
fig = px.line(x=x, y=y)
fig.show()
Bar Chart
import plotly.express as px
x = ["Python", "Java", "C", "C++", "C#"]
y = [50, 45, 30, 40, 43]
# Create the bar chart
fig = px.bar(x=x, y=y, title="My Bar Chart")
fig.show()
Pie Chart
import plotly.express as px
# Loaded a 'tips' dataset from plotly
df = px.data.tips()
fig = px.pie(df, values='tip', names='day')
fig.show()
Data Visualization Best Practices
Data visualization is an effective way to communicate complex information and insights, but it's important to follow some best practices to ensure that your visualizations are effective and meaningful. Here are some of the most important best practices for Data Visualization:
Before creating a visualization, consider who your audience is and what message you want to convey. This will help you choose the appropriate type of visualization and design elements.
Choose the type of visualization that best represents the data you want to communicate. For example, use a bar chart for categorical data and a line chart for continuous data.
Avoid using too many elements or colors in your visualization, as this can make it confusing or overwhelming.
Choose a scale that accurately represents the range of values in your data.
Before creating a visualization, validate your data to ensure that it is accurate and meaningful.
Now, we are in the final touch of this beginner’s guide. In conclusion, Data Visualization is a powerful tool for understanding and analyzing data. I hope now you are able to create your own plots and start visualizing your data and can quickly identify patterns and trends in data using some of the most popular libraries such as Matplotlib, Seaborn and Plotly.
Thank You Readers 🙂
Happy Learning !!!