Data Visualization using Matplotlib

Mastering Python Data Visualization using Matplotlib

Table of Contents

Data Visualization in Python

Data visualization in Python involves representing data in a graphical format, making it easier to identify patterns, trends, and outliers. Python offers several libraries for data visualization, with Matplotlib, Seaborn, and Plotly being some of the most popular. These libraries provide a wide range of plotting functions and customization options to create informative and aesthetically pleasing visual representations of data.

Why Use Data Visualization?

1. Pattern Recognition: Helps identify patterns and trends in data that may not be apparent from raw numbers.
2. Data Exploration: Facilitates the exploratory data analysis (EDA) process to uncover insights and inform further analysis.
3. Communication: Effectively communicates findings and insights to stakeholders through clear and concise visuals.
4. Decision Making: Supports data-driven decision-making by presenting data in an intuitive and understandable format.

Best Practices for Data Visualization

1. Clarity: Ensure that the visualizations are clear and easy to understand.
2. Accuracy: Represent the data accurately without distorting the information.
3. Simplicity: Avoid unnecessary complexity; keep the design simple and focused.
4. Consistency: Use consistent colors, scales, and labeling across different plots.Context: Provide context with appropriate titles, labels, legends, and annotations.

Data visualization is a crucial aspect of data analysis and communication, enabling data scientists and analysts to convey complex information effectively and support data-driven decisions. Read More

Key Libraries for Data Visualization in Python

Matplotlib

Matplotlib is a widely used Python library for creating static, animated, and interactive visualizations. It is highly versatile and allows users to generate a variety of plots and charts, including line plots, bar charts, histograms, scatter plots, and more. Here’s an overview:

Key Features:

1. Versatility: Create a wide range of plots from simple line charts to complex multi-panel figures.
2. Customizability: Extensive options for customizing the appearance of plots, including colors, markers, line styles, and labels.
3. Integration: Works well with other libraries like NumPy and pandas, making it easy to visualize data from these sources.
4. Interactivity: Supports interactive plotting features with tools like Matplotlib’s widgets and integration with Jupyter notebooks.
5. Static, Animated, and Interactive Plots: Generate static images, animations, and interactive plots to enhance data analysis.

Example:

import matplotlib.pyplot as plt

# Data
x = [10, 15, 20, 25, 15]
y = [20, 30, 50, 70, 100]

# Create a line plot
plt.plot(x, y)

# Add labels and title
plt.xlabel('X-axis Label')
plt.ylabel('Y-axis Label')
plt.title('Line Plot')

# Display the plot
plt.show()

Output:

Common Plot Types:

• Line Plots: Ideal for showing trends over time.
• Bar Charts: Useful for comparing quantities across categories.
• Histograms: Show the distribution of data points.
• Scatter Plots: Reveal relationships between two variables.

• Matplotlib is a foundational tool in data science and analytics, widely used for its flexibility and comprehensive range of plotting capabilities.
• Matplotlib is a powerful library for creating static, animated, and interactive visualizations in Python. It is particularly useful for creating line plots, bar charts, histograms, and scatter plots. In this session, we will cover:

1. Basic Plots
2. Customization
3. Subplots
4. Histograms
5. Scatter Plots

Basic Plots

Basic plots include line plots and bar charts, which are the simplest forms of data visualization.

Line Plot Example

import matplotlib.pyplot as plt

# Data
x = [1, 2, 3, 4, 5]
y = [2, 3, 5, 7, 11]

# Create a line plot
plt.plot(x, y)

# Add labels and title
plt.xlabel('X-axis Label')
plt.ylabel('Y-axis Label')
plt.title('Line Plot Example')

# Display the plot
plt.show()

Output:

Explanation:

• Plot: Shows a simple line plot with points connected by a line.
• Labels and Title: The x-axis is labeled “X-axis Label”, the y-axis is labeled “Y-axis Label”, and the plot has a title “Line Plot Example”.

Customization

Customization allows you to modify the appearance of your plots, including colors, line styles, and markers.

Customization Example

import matplotlib.pyplot as plt

# Data
x = [1, 2, 3, 4, 5]
y = [2, 3, 5, 7, 11]

# Create a customized line plot
plt.plot(x, y, color='green', linestyle='--', marker='o')

# Add labels, title, and legend
plt.xlabel('X-axis Label')
plt.ylabel('Y-axis Label')
plt.title('Customized Line Plot')
plt.legend(['Data Line'])

# Display the plot
plt.show()

Output:

Explanation:

• Color: The line color is green.
• Line Style: The line is dashed.
• Marker: Data points are marked with circles.
• Legend: Adds a legend to describe the data line.

Subplots

Subplots allow you to create multiple plots in a single figure, useful for comparing different datasets or different views of the same dataset.

Subplots Example

import matplotlib.pyplot as plt

# Create a figure with 2x2 subplots
fig, axs = plt.subplots(2, 2)

# Data
x = [1, 2, 3, 4, 5]
y1 = [2, 3, 5, 7, 11]
y2 = [1, 4, 6, 8, 10]
y3 = [5, 6, 7, 8, 9]
y4 = [7, 8, 9, 10, 11]

# Plot in each subplot
axs[0, 0].plot(x, y1)
axs[0, 0].set_title('Plot 1')

axs[0, 1].plot(x, y2, 'tab:orange')
axs[0, 1].set_title('Plot 2')

axs[1, 0].plot(x, y3, 'tab:green')
axs[1, 0].set_title('Plot 3')

axs[1, 1].plot(x, y4, 'tab:red')
axs[1, 1].set_title('Plot 4')

# Set common labels
for ax in axs.flat:
    ax.set(xlabel='X-axis', ylabel='Y-axis')

# Adjust layout
plt.tight_layout()

# Display the plots
plt.show()

Output:

Explanation:

• Subplots: A 2×2 grid of subplots with different data plotted in each subplot.
• Titles and Labels: Each subplot has its own title and shared x and y-axis labels.
• Layout:plt.tight_layout() adjusts the layout to prevent overlap.

Histograms

Histograms represent the distribution of a dataset by dividing the data into bins and counting the number of observations in each bin.

Histogram Example

import numpy as np
import matplotlib.pyplot as plt

# Generate random data
data = np.random.randn(1000)

# Create a histogram
plt.hist(data, bins=30, alpha=0.7, color='blue')

# Add labels and title
plt.xlabel('Value')
plt.ylabel('Frequency')
plt.title('Histogram Example')

# Display the histogram
plt.show()

Output:

Explanation:

• Histogram: Shows the distribution of random data with 30 bins.
• Labels and Title: The x-axis is labeled “Value”, the y-axis is labeled “Frequency”, and the plot has a title “Histogram Example”.

Scatter Plots

Scatter plots display individual data points, useful for showing the relationship between two variables.

Scatter Plot Example

import matplotlib.pyplot as plt

# Data
x = [1, 2, 3, 4, 5]
y = [2, 3, 5, 7, 11]

# Create a scatter plot
plt.scatter(x, y, color='red')

# Add labels and title
plt.xlabel('X-axis Label')
plt.ylabel('Y-axis Label')
plt.title('Scatter Plot Example')

# Display the scatter plot
plt.show()

Output:

Explanation:

• Scatter Plot: Displays individual data points with red markers.
• Labels and Title: The x-axis is labeled “X-axis Label”, the y-axis is labeled “Y-axis Label”, and the plot has a title “Scatter Plot Example”.

Best Practices

1. Consistent Style: Maintain a consistent style across all plots to improve readability.
   • Example: Use a common color palette and line styles.

plt.style.use('seaborn-darkgrid')

2. Label Everything: Always label your axes and add a title to your plots.
   • Example:

plt.xlabel('X-axis Label')
plt.ylabel('Y-axis Label')
plt.title('Plot Title')

3. Legends: Use legends to explain different data series in your plots.
   • Example:

plt.legend(['Data Line'])

4. Save Plots: Save your plots for future reference or publication.
   • Example:

plt.savefig('plot.png')

5. Subplots for Comparison: Use subplots to compare multiple datasets within a single figure.
   • Example:

fig, axs = plt.subplots(2, 2)

# matplotlib_functions.py

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

# Generate sample data
x = np.linspace(0, 10, 100)
y = np.sin(x)
data = pd.DataFrame({'x': x, 'y': y})

# 1. Line Plot
# A basic plot that shows the relationship between two variables.
plt.figure()
plt.plot(x, y, label='sin(x)')
plt.title('Line Plot')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.legend()
plt.show()

# 2. Scatter Plot
# Used to plot individual data points.
plt.figure()
plt.scatter(x, y, label='data points')
plt.title('Scatter Plot')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.legend()
plt.show()

# 3. Bar Plot
# Used to plot categorical data.
categories = ['A', 'B', 'C']
values = [10, 24, 36]
plt.figure()
plt.bar(categories, values, color=['red', 'blue', 'green'])
plt.title('Bar Plot')
plt.xlabel('Categories')
plt.ylabel('Values')
plt.show()

# 4. Histogram
# Used to show the distribution of a numerical variable.
data = np.random.randn(1000)
plt.figure()
plt.hist(data, bins=30, edgecolor='black')
plt.title('Histogram')
plt.xlabel('Value')
plt.ylabel('Frequency')
plt.show()

# 5. Box Plot
# Used to show the distribution of a dataset based on a five-number summary.
data = [np.random.normal(0, std, 100) for std in range(1, 4)]
plt.figure()
plt.boxplot(data, vert=True, patch_artist=True)
plt.title('Box Plot')
plt.xlabel('Category')
plt.ylabel('Value')
plt.show()

# 6. Violin Plot
# Combines the benefits of box plots and KDE.
plt.figure()
plt.violinplot(data, showmeans=False, showmedians=True)
plt.title('Violin Plot')
plt.xlabel('Category')
plt.ylabel('Value')
plt.show()

# 7. Pie Chart
# Used to show the proportions of a whole.
sizes = [15, 30, 45, 10]
labels = ['A', 'B', 'C', 'D']
plt.figure()
plt.pie(sizes, labels=labels, autopct='%1.1f%%', startangle=140)
plt.title('Pie Chart')
plt.show()

# 8. Subplots
# Multiple plots in one figure.
fig, axs = plt.subplots(2, 2, figsize=(10, 10))

# Line plot
axs[0, 0].plot(x, y)
axs[0, 0].set_title('Line Plot')

# Scatter plot
axs[0, 1].scatter(x, y)
axs[0, 1].set_title('Scatter Plot')

# Bar plot
axs[1, 0].bar(categories, values, color=['red', 'blue', 'green'])
axs[1, 0].set_title('Bar Plot')

# Histogram
axs[1, 1].hist(data[0], bins=30, edgecolor='black')
axs[1, 1].set_title('Histogram')

plt.tight_layout()
plt.show()

# 9. Heatmap
# Used to show the magnitude of a phenomenon as color in two dimensions.
data = np.random.rand(10, 10)
plt.figure()
plt.imshow(data, cmap='hot', interpolation='nearest')
plt.title('Heatmap')
plt.colorbar()
plt.show()

# 10. 3D Plot
# Used to plot data in three dimensions.
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
z = np.linspace(0, 10, 100)
x = np.sin(z)
y = np.cos(z)
ax.plot(x, y, z)
ax.set_title('3D Plot')
plt.show()

# 11. Error Bars
# Used to show the variability of data.
x = np.linspace(0, 10, 10)
dy = 0.2
y = np.sin(x) + dy * np.random.randn(10)
plt.figure()
plt.errorbar(x, y, yerr=dy, fmt='.k')
plt.title('Error Bars')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.show()

# 12. Stem Plot
# Used to plot data points as stems.
plt.figure()
plt.stem(x, y, use_line_collection=True)
plt.title('Stem Plot')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.show()

# 13. Step Plot
# Used to plot data as steps.
plt.figure()
plt.step(x, y, where='mid')
plt.title('Step Plot')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.show()

# 14. Fill Between
# Used to fill the area between two curves.
y1 = np.sin(x)
y2 = np.sin(x) + 0.5
plt.figure()
plt.fill_between(x, y1, y2, color='lightblue')
plt.title('Fill Between')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.show()

# 15. Polar Plot
# Used to plot data in polar coordinates.
theta = np.linspace(0, 2 * np.pi, 100)
r = np.abs(np.sin(theta))
plt.figure()
plt.polar(theta, r)
plt.title('Polar Plot')
plt.show()

# 16. Logarithmic Plot
# Used to plot data with logarithmic scaling.
x = np.logspace(0.1, 2, 100)
y = np.exp(x)
plt.figure()
plt.plot(x, y)
plt.xscale('log')
plt.yscale('log')
plt.title('Logarithmic Plot')
plt.xlabel('Log(X-axis)')
plt.ylabel('Log(Y-axis)')
plt.show()

# 17. Quiver Plot
# Used to plot vectors as arrows.
x, y = np.meshgrid(np.arange(-10, 10, 1), np.arange(-10, 10, 1))
u = -1 - x**2 + y
v = 1 + x - y**2
plt.figure()
plt.quiver(x, y, u, v)
plt.title('Quiver Plot')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.show()

# 18. Stream Plot
# Used to plot vector fields.
plt.figure()
plt.streamplot(x, y, u, v)
plt.title('Stream Plot')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.show()

# 19. Contour Plot
# Used to plot contours of a function.
X, Y = np.meshgrid(np.linspace(-3, 3, 100), np.linspace(-3, 3, 100))
Z = np.sin(np.sqrt(X**2 + Y**2))
plt.figure()
plt.contour(X, Y, Z)
plt.title('Contour Plot')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.show()

# 20. Tri-Surface Plot
# Used to plot a triangulated surface.
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x = np.random.rand(100)
y = np.random.rand(100)
z = np.random.rand(100)
ax.plot_trisurf(x, y, z)
ax.set_title('Tri-Surface Plot')
plt.show()

Explanation of Functions

1. Line Plot: plt.plot() creates a simple line plot.
2. Scatter Plot: plt.scatter() creates a scatter plot with individual data points.
3. Bar Plot: plt.bar() creates a bar plot for categorical data.
4. Histogram: plt.hist() shows the distribution of a dataset.
5. Box Plot: plt.boxplot() displays the distribution based on a five-number summary.
6. Violin Plot: plt.violinplot() combines box plot and KDE to show distributions.
7. Pie Chart: plt.pie() shows proportions of a whole.
8. Subplots: plt.subplots() creates multiple plots in one figure.
9. Heatmap: plt.imshow() displays a matrix of data with color-coded values.
10. 3D Plot: ax.plot() creates a 3D plot.
11. Error Bars: plt.errorbar() shows variability of data.
12. Stem Plot: plt.stem() plots data points as stems.
13. Step Plot: plt.step() plots data as steps.
14. Fill Between: plt.fill_between() fills the area between two curves.
15. Polar Plot: plt.polar() creates a plot in polar coordinates.
16. Logarithmic Plot: plt.plot() with set_xscale('log') and set_yscale('log') creates a logarithmic plot.
17. Quiver Plot: plt.quiver() plots vectors as arrows.
18. Stream Plot: plt.streamplot() plots vector fields.
19. Contour Plot: plt.contour() plots contours of a function.
20. Tri-Surface Plot: ax.plot_trisurf() creates a triangulated surface plot.

Seaborn

• Overview: Built on top of Matplotlib, Seaborn provides a high-level interface for drawing attractive statistical graphics. It simplifies the creation of complex visualizations.
• Use Cases: Heatmaps, time series, categorical plots, and distribution plots.
• Example:

import seaborn as sns
import matplotlib.pyplot as plt

# Load dataset
tips = sns.load_dataset('tips')

# Create a box plot
sns.boxplot(x='day', y='total_bill', data=tips)

# Display the plot
plt.show()

Exercises

Exercise: Create Various Plots to Visualize a Dataset

1. Dataset: Use any dataset you prefer, such as one from the Seaborn library or generated using NumPy.

import seaborn as sns
data = sns.load_dataset('iris')

Tasks–

1. Line Plot: Create a line plot of the sepal length vs. sepal width.
2. Customization: Customize the line plot with different colors, line styles, and markers.
3. Subplot: Create a subplot with sepal length vs. sepal width and petal length vs. petal width.
4. Histogram: Generate a histogram to show the distribution of sepal length.
5. Scatter Plot: Create a scatter plot to show the relationship between sepal length and petal length.

Plotly

• Overview: A graphing library that makes interactive, publication-quality graphs online. Plotly can create interactive plots that can be embedded in web applications.
• Use Cases: Interactive line plots, bar charts, scatter plots, 3D plots, and dashboards.
• Example:

import plotly.express as px

# Data
df = px.data.iris()

# Create a scatter plot
fig = px.scatter(df, x='sepal_width', y='sepal_length', color='species')

# Display the plot
fig.show()

Comprehensive Practice Exercises

Exercise 1: Basic Line Plot

Question: Create a simple line plot showing the relationship between two sets of data points: x = [0, 1, 2, 3, 4] and y = [0, 2, 4, 6, 8]. Add appropriate labels for the x-axis and y-axis and a title for the plot.

Hint: Use the plt.plot() function to create the line plot, and plt.xlabel(), plt.ylabel(), and plt.title() to add labels and a title.

Expectation: You should see a straight line with labels on both axes and a title at the top.

Exercise 2: Bar Chart

Question: Create a bar chart representing the number of students in different classes. Use the classes [‘Class A’, ‘Class B’, ‘Class C’] and the corresponding number of students [30, 25, 40]. Customize the colors and add grid lines.

Hint: Use the plt.bar() function to create the bar chart. Customize colors using the color parameter and add grid lines using plt.grid(True).

Expectation: A bar chart with three bars in different colors, with grid lines for better readability.

Exercise 3: Histogram

Question: Generate random data following a normal distribution and create a histogram to visualize the distribution. Use 1000 data points and 30 bins. Add a density plot overlay to show the data’s distribution curve.

Hint: Use np.random.randn() to generate the data and plt.hist() to create the histogram. Overlay the density plot using sns.kdeplot() from the Seaborn library.

Expectation: A histogram with bars showing the frequency distribution and a smooth density curve overlay.

Exercise 4: Subplots

Question: Create a figure with four subplots (2×2 grid) showing different types of plots: line plot, scatter plot, histogram, and bar chart. Use random data for the plots.

Hint: Use plt.subplots() to create the grid of subplots and axs[row, col] to access each subplot. Use different plotting functions (plt.plot(), plt.scatter(), plt.hist(), plt.bar()) for each subplot.

Expectation: A figure with four distinct subplots, each demonstrating a different type of plot.

Exercise 5: Scatter Plot with Regression Line

Question: Create a scatter plot showing the relationship between two variables. Generate 50 random data points for x and y, and add a regression line to indicate the trend.

Hint: Use np.random.rand() to generate random data and sns.regplot() to create the scatter plot with a regression line.

Expectation: A scatter plot with individual data points and a fitted regression line showing the overall trend.

Exercise 6: Pie Chart with Percentages

Question: Create a pie chart showing the market share of different companies. Use the companies [‘Company A’, ‘Company B’, ‘Company C’, ‘Company D’] and their respective market shares [35, 25, 25, 15]. Display the percentage for each segment.

Hint: Use plt.pie() to create the pie chart and autopct='%1.1f%%' to display percentages.

Expectation: A pie chart with four segments, each labeled with the corresponding company and its market share percentage.

Exercise 7: Box Plot for Data Distribution

Question: Generate random data for four different groups and create a box plot to visualize the data distribution. Use 100 data points for each group and ensure the plot includes quartiles and potential outliers.

Hint: Use np.random.normal() to generate the data and plt.boxplot() to create the box plot.

Expectation: A box plot with four boxes, each representing a different group’s data distribution, showing the median, quartiles, and any outliers.

Exercise 8: Customizing Plot Appearance

Question: Create a line plot with multiple lines to compare different datasets. Use the data: x = [1, 2, 3, 4, 5], y1 = [1, 4, 9, 16, 25], y2 = [1, 2, 3, 4, 5]. Customize the line styles, colors, and markers. Add a legend to distinguish between the datasets.

Hint: Use plt.plot() with different line styles, colors, and markers (e.g., linestyle='--', color='red', marker='o'). Add a legend using plt.legend().

Expectation: A line plot with two lines, each with distinct styles and markers, and a legend indicating which line corresponds to which dataset.

Exercise 9: Annotating Plots

Question: Create a scatter plot and annotate specific points of interest. Use the data: x = [1, 2, 3, 4, 5], y = [2, 3, 5, 7, 11]. Annotate the point (3, 5) with the label ‘Important Point’.

Hint: Use plt.scatter() to create the scatter plot and plt.annotate() to add the annotation.

Expectation: A scatter plot with an annotation pointing to the specified data point, clearly labeled as ‘Important Point’.

Exercise 10: Combining Multiple Plots

Question: Combine a line plot and a bar chart in a single figure to compare monthly sales data. Use the data: months = [‘Jan’, ‘Feb’, ‘Mar’, ‘Apr’, ‘May’], sales = [100, 150, 200, 250, 300], costs = [80, 130, 180, 230, 280]. Plot the sales as a line plot and the costs as a bar chart.

Hint: Use plt.plot() for the line plot and plt.bar() for the bar chart. Overlay them in a single figure by calling the plot functions sequentially.

Expectation: A combined figure with both a line plot and a bar chart, effectively showing the comparison between sales and costs for each month.

Interview Questions and Answers

1. Q: What is Matplotlib?
   • A: Matplotlib is a plotting library for the Python programming language and its numerical mathematics extension NumPy. It provides an object-oriented API for embedding plots into applications and offers a variety of plot types and customization options.
2. Q: How do you create a basic line plot in Matplotlib?
   • A: To create a basic line plot, use plt.plot(x, y) where x and y are lists or arrays of data points. Add labels and a title using plt.xlabel(), plt.ylabel(), and plt.title(), and then call plt.show() to display the plot.
3. Q: What are some common customization options in Matplotlib?
   • A: Common customization options include changing line colors (color), line styles (linestyle), markers (marker), and adding gridlines (plt.grid()). You can also adjust axis limits (plt.xlim(), plt.ylim()) and labels.
4. Q: How do you add a legend to a plot?
   • A: Add a legend using plt.legend(). Specify the labels for each line or data series using the label parameter in the plot function. The legend will automatically use these labels.
5. Q: What is a subplot in Matplotlib?
   • A: A subplot is a way to display multiple plots in a single figure. You can create subplots using plt.subplots(nrows, ncols) where nrows and ncols specify the number of rows and columns of subplots.
6. Q: How do you create a histogram in Matplotlib?
   • A: Use plt.hist(data, bins) where data is a list or array of values and bins is the number of bins you want to use. Customize the histogram with alpha for transparency and color for the color of the bars.
7. Q: What is the purpose of plt.tight_layout()?
   • A: plt.tight_layout() adjusts the spacing between subplots to prevent overlap and ensure that labels and titles are visible and not cut off.
8. Q: How can you save a plot to a file in Matplotlib?
   • A: Save a plot using plt.savefig('filename.png'), specifying the file name and format (e.g., PNG, PDF). This method saves the current figure to a file.
9. Q: How do you create a scatter plot?
   • A: Use plt.scatter(x, y) where x and y are lists or arrays of data points. Customize the scatter plot with options like color, s (size of markers), and c (color map).
10. Q: What is the difference between plt.plot() and plt.scatter()?
    • A: plt.plot() creates line plots connecting data points, while plt.scatter() creates scatter plots displaying individual data points without connecting lines.
11. Q: How do you add annotations to a plot?
    • A: Use plt.annotate('text', xy=(x, y)) where 'text' is the annotation text, and xy specifies the point to annotate. Customize the appearance with additional parameters.
12. Q: What is a box plot and when would you use it?
    • A: A box plot displays the distribution of data based on quartiles and highlights outliers. It is useful for visualizing data spread and comparing distributions across multiple groups.
13. Q: How can you modify the size of a plot?
    • A: Modify the size of a plot by specifying the figsize parameter in plt.subplots(figsize=(width, height)) where width and height are in inches.
14. Q: How do you plot multiple datasets on the same plot?
    • A: Plot multiple datasets by calling plt.plot() or plt.scatter() multiple times before calling plt.show(). Use different colors or markers to distinguish between datasets.
15. Q: What is the purpose of the alpha parameter in Matplotlib?
    • A: The alpha parameter controls the transparency of the plot elements. Values range from 0 (completely transparent) to 1 (completely opaque).
16. Q: How do you create a pie chart in Matplotlib?
    • A: Use plt.pie(sizes, labels=labels, autopct='%1.1f%%') where sizes is a list of proportions, labels are the categories, and autopct displays percentage labels.
17. Q: What does plt.grid(True) do?
    • A: plt.grid(True) enables grid lines on the plot. Grid lines help to visualize the data points and make the plot easier to read.
18. Q: How can you adjust the limits of the x and y axes?
    • A: Adjust axis limits with plt.xlim(lower, upper) and plt.ylim(lower, upper), where lower and upper are the limits for the respective axis.
19. Q: How do you change the font size of plot labels and titles?
    • A: Change the font size using the fontsize parameter in plt.xlabel(), plt.ylabel(), and plt.title(). For example: plt.xlabel('X-axis', fontsize=14).
20. Q: How can you display the plot without using plt.show()?
    • A: Display the plot inline in Jupyter notebooks by using %matplotlib inline magic command at the beginning of the notebook. This renders plots automatically without needing plt.show().

These questions cover fundamental concepts, common use cases, and advanced customization techniques in Matplotlib, providing a comprehensive overview for interview preparation.