Building Insightful Visuals: Data-Driven Graph Analysis in Python#

Installation Methods#

1. Anaconda Distribution: Easiest for data science and data visualization work due to pre-installed libraries like NumPy, pandas, and matplotlib.
2. PyPI (pip): More lightweight. You can install individual packages using pip.
3. Virtual Environments: Recommended to isolate project dependencies and avoid conflicts.

For more advanced projects or collaborating in teams, adopting best practices like using virtual environments ensures reproducibility.

Verifying Your Environment#

Once you decide on an installation method, verify that Python and the required libraries are installed correctly. For example, if you use Anaconda:

1
conda --version
2
conda list

To confirm installed libraries in a pip environment:

1
pip --version
2
pip freeze

Handling Missing and Malformed Data#

Real-world datasets can have:

• Missing data: Entire columns might be empty or partially filled.
• Inconsistent formats: Some entries might be strings or invalid formats for numeric columns.
• Outliers: Extremely high or low values that could skew your analysis.

Resolving these issues might involve:

• Replacing missing values with mean or median.
• Dropping rows or columns if data is insufficient or too noisy.
• Converting columns to the correct data types.
• Filtering or capping outliers.

Line Plots#

Line plots are ideal for time-series data or scenarios where you want to observe trends. Python’s matplotlib library can produce quick line plots:

1
import matplotlib.pyplot as plt
2

3
# Suppose df_monthly is the DataFrame from the previous step
4
plt.figure(figsize=(10, 6))
5
plt.plot(df_monthly.index, df_monthly['Revenue'], marker='o', linestyle='-', color='blue')
6
plt.title('Monthly Revenue Over Time')
7
plt.xlabel('Date')
8
plt.ylabel('Revenue')
9
plt.grid(True)
10
plt.show()

This snippet:

1. Sets a figure size of 10 x 6 inches.
2. Plots the “Revenue�?column across monthly time data.
3. Labels axes and sets a title.
4. Displays a grid for easier reading.
5. Shows the plot on the screen.

Bar Charts#

Bar charts are great for comparing discrete categories. Let’s assume you have data for different product categories:

1
product_groups = df.groupby('Product_Category')['Revenue'].sum()
2

3
plt.figure(figsize=(10, 6))
4
plt.bar(product_groups.index, product_groups.values, color='green')
5
plt.title('Revenue by Product Category')
6
plt.xlabel('Product Category')
7
plt.ylabel('Total Revenue')
8
plt.xticks(rotation=45)
9
plt.show()

You can see how grouping data by a column in your DataFrame and then using a bar chart quickly communicates which categories bring in the most revenue.

Scatter Plots#

Scatter plots are instrumental in exploring relationships between two variables. Imagine you want to examine the correlation between product price and units sold:

1
plt.figure(figsize=(10, 6))
2
plt.scatter(df['Price'], df['Units_Sold'], alpha=0.5, c='red')
3
plt.title('Price vs. Units Sold')
4
plt.xlabel('Price')
5
plt.ylabel('Units Sold')
6
plt.grid(True)
7
plt.show()

Adjusting the alpha (transparency) reduces overlap when data points are dense. Layering additional dimensions (e.g., color by category, size by revenue) can uncover multi-variate relationships.

Grouped Bar Charts#

When multiple categories or sub-categories are involved, grouped bar charts provide more granular comparisons. Suppose you want to plot revenue by product category across multiple regions:

1
grouped_data = df.groupby(['Region', 'Product_Category'])['Revenue'].sum().unstack()
2

3
grouped_data.plot(kind='bar', figsize=(12, 7))
4
plt.title('Revenue by Region and Product Category')
5
plt.xlabel('Region')
6
plt.ylabel('Revenue')
7
plt.xticks(rotation=0)
8
plt.legend(title='Product Category')
9
plt.tight_layout()
10
plt.show()

This unstack transformation pivoted the data to make each product category into a column while grouping by region on the rows. Each region now shows separate bars for each product category.

Stacked Area Plots#

Stacked area plots can reveal how individual segments contribute to a total over time. For instance, if you have a time series of product sales by category:

1
df_daily = df.resample('D', on='Date').sum()  # Summing up daily data
2
product_daily = df.groupby(['Date', 'Product_Category'])['Revenue'].sum().unstack()
3

4
product_daily.fillna(0, inplace=True)
5

6
plt.figure(figsize=(12, 7))
7
plt.stackplot(product_daily.index,
8
              [product_daily[col] for col in product_daily.columns],
9
              labels=product_daily.columns)
10
plt.title('Daily Revenue by Product Category')
11
plt.xlabel('Date')
12
plt.ylabel('Revenue')
13
plt.legend(loc='upper left')
14
plt.show()

Each segment in the stack shows how that product category’s revenue contributes to the total daily revenue.

Heatmaps#

A heatmap is especially useful for showing correlations or intensities. Here’s a straightforward example of evaluating the correlation matrix for numerical columns:

1
import seaborn as sns
2

3
plt.figure(figsize=(8, 6))
4
corr_matrix = df.corr(numeric_only=True)
5
sns.heatmap(corr_matrix, annot=True, cmap='Blues')
6
plt.title('Correlation Heatmap')
7
plt.show()

This allows you to see which numerical fields are positively or negatively correlated. Visualizing correlations is fundamental when performing preliminary analyses.

Pair Plots#

Pair plots (also known as scatterplot matrices) help you visualize relationships between multiple numeric variables, while also showing each variable’s distribution:

1
sns.pairplot(df[['Price', 'Units_Sold', 'Revenue']], diag_kind='kde', height=3)
2
plt.show()

This single command provides a grid of scatter plots and kernel density estimates for each numeric feature, making it easy to observe potential correlations or clusters.

Installing and Importing Plotly#

If you do not already have Plotly, install it using:

1
pip install plotly

Use it in a Python script or Jupyter Notebook:

1
import plotly.express as px

Interactive Line Chart#

Let’s visualize the monthly revenue data interactively:

1
fig = px.line(df_monthly, x=df_monthly.index, y='Revenue', title='Monthly Revenue Over Time')
2
fig.show()

When you open this figure in a browser or notebook environment, you can hover over data points to get exact values, zoom into specific date ranges, and explore time-based data more conveniently.

Interactive Bar Chart#

Sometimes, interactivity is necessary when the dataset is large or complex. Below is an interactive bar chart comparing average revenue by product category:

1
avg_revenue_by_category = df.groupby('Product_Category')['Revenue'].mean().reset_index()
2
fig = px.bar(avg_revenue_by_category, x='Product_Category', y='Revenue',
3
             title='Average Revenue by Product Category',
4
             hover_data=['Product_Category'])
5
fig.show()

By default, Plotly integrates well with pandas DataFrames, making it straightforward to control the chart’s dimensions and attributes. You can add custom hover templates, color scales, or facet the data by additional columns.

Installing and Importing NetworkX#

1
pip install networkx

After installation:

1
import networkx as nx

Constructing Graphs#

There are multiple ways to build a NetworkX graph:

1. Edge List: A list of tuples (source, target).
2. Adjacency List or Dictionary: Maps from a node to all connected nodes.
3. From Pandas DataFrame: If you have columns representing edges.

Here’s an example of creating a graph from a simple edge list:

1
G = nx.Graph()
2

3
# Suppose you have a list of edges
4
edges = [('A', 'B'), ('B', 'C'), ('C', 'D'), ('A', 'D'), ('D', 'E')]
5
G.add_edges_from(edges)

Adding Attributes#

Networks can include additional data about nodes and edges, such as weights, statuses, or categories:

1
# Add node attributes
2
G.nodes['A']['type'] = 'start'
3
G.nodes['B']['type'] = 'intermediate'
4

5
# Add edge attributes
6
G['A']['B']['weight'] = 0.8
7
G['B']['C']['weight'] = 0.5

Visualization#

NetworkX offers basic drawing capabilities, though for advanced or interactive displays you may prefer specialized packages. Here’s a basic layout:

1
import matplotlib.pyplot as plt
2

3
pos = nx.spring_layout(G, seed=42)  # Positions for nodes
4
nx.draw_networkx_nodes(G, pos, node_size=700, node_color='skyblue')
5
nx.draw_networkx_edges(G, pos, width=2, edge_color='gray')
6
nx.draw_networkx_labels(G, pos, font_size=12, font_family='sans-serif')
7

8
plt.title('Basic Network Graph')
9
plt.axis('off')
10
plt.show()

You can customize node shapes, colors, edge thicknesses, and label positions. The spring_layout tries to position nodes to reduce edge overlaps, but you can explore other layouts like circular_layout, random_layout, and shell_layout.

Simple Network Analysis#

NetworkX includes various algorithms for analyzing the structure of your network:

• Degree centrality: Measures how many connections each node has.
• Clustering coefficients: Measures how nodes cluster together.
• Shortest paths: Computes the shortest route between nodes for weighted or unweighted edges.
• Connected components: Identifies distinct subgraphs in an unconnected network.

For instance, to compute degree centrality:

1
deg_centrality = nx.degree_centrality(G)
2
for node, centrality_value in deg_centrality.items():
3
    print(f"Node {node} has a degree centrality of {centrality_value}")

This quick analysis helps identify which nodes are the most “influential�?or well-connected.