• Computation: Specifically, you can use the numpy.random.power function, which draws samples from a power-law distribution with a specific exponent.
• Visualization: After generating the samples, it’s beneficial to visualize them in a log-log space to observe the characteristic straight-line behavior of power-law distributions. This visualization helps in understanding the distribution’s properties and confirming its power-law nature.

Here’s a minimal code example to generate and visualize random samples from a power-law distribution:

import numpy as np
import matplotlib.pyplot as plt

# Parameters
a = 5  # Shape parameter
samples = 10000  # Number of samples

# Generate random samples
data = np.random.power(a, samples)

# Visualization in log-log space
counts, bins = np.histogram(data, bins=50)
bins_center = (bins[:-1] + bins[1:]) / 2
plt.loglog(bins_center, counts, marker='o', linestyle='none')

plt.xlabel('Value')
plt.ylabel('Frequency')
plt.title('Power-law distribution in log-log space')
plt.show()

First, we import the necessary libraries: numpy for generating the power-law distributed samples and matplotlib.pyplot for plotting.

The a parameter is the shape parameter of the power-law distribution, controlling the steepness of the distribution. The samples variable defines how many random values we want to generate.

np.random.power(a, samples) generates an array of samples drawn from a power-law distribution with the shape parameter a.

To visualize the distribution in log-log space, we first compute the histogram of the data using np.histogram, which returns the counts and the bin edges.

We calculate the center of each bin for plotting purposes (bins_center) and then plot the histogram using plt.loglog to create a log-log plot. This is crucial for visualizing power-law distributions as they appear as straight lines in log-log plots.

Finally, we label the axes and show the plot with plt.show().

Creating Power Law Distribution Without Library Such As NumPy

To create samples from a power-law distribution without a library, we use the inverse transform sampling method, where we generate uniform random samples and apply the inverse of the distribution’s cumulative distribution function (CDF) to these samples. This approach mathematically transforms uniformly distributed random numbers into numbers that follow the desired power-law distribution, based on the power-law’s specific characteristics and parameters.

Here’s the code:

import random
import matplotlib.pyplot as plt

def generate_power_law_samples(alpha, size=1000, xmin=1):
    """Generate samples from a power-law distribution using the inverse transform sampling method."""
    samples = []
    for _ in range(size):
        u = random.random()  # Uniform random sample from 0 to 1
        x = xmin * (1 - u) ** (-1 / (alpha - 1))
        samples.append(x)
    return samples

def plot_rank_frequency(samples):
    """Plot samples in log-log space using rank-frequency."""
    # Sort samples in descending order
    sorted_samples = sorted(samples, reverse=True)
    # Generate ranks
    ranks = range(1, len(sorted_samples) + 1)
    # Plotting
    plt.loglog(ranks, sorted_samples, marker='o', linestyle='none')
    plt.xlabel('Rank')
    plt.ylabel('Sample Value')
    plt.title('Power-law distribution rank-frequency plot in log-log space')
    plt.show()

# Generate samples
alpha = 2.5  # Shape parameter of the power-law distribution
samples = generate_power_law_samples(alpha, 10000)

# Plot rank-frequency in log-log space
plot_rank_frequency(samples)

This code generates samples from a power-law distribution using the generate_power_law_samples function, as before.

The plot_rank_frequency function sorts the samples in descending order and then generates their ranks. In a rank-frequency plot, each point’s x-coordinate is its rank (i.e., its position in the sorted list), and its y-coordinate is the sample value itself.

We plot these points in a log-log space using plt.loglog(). This type of plot is useful for observing the power-law behavior of the distribution, where a linear relationship in log-log space indicates a power-law distribution.

The plot’s x-axis represents the ranks of the samples, and the y-axis represents the sample values, both on logarithmic scales. This visualization technique is effective for highlighting the characteristics of power-law distributions.

The post How to Generate and Plot Random Samples from a Power-Law Distribution in Python? appeared first on Be on the Right Side of Change.

One of the most revealing ways to examine this distribution is through a log/log plot of the net worths of the world’s richest individuals. Here’s how to visualize the net worth of the top 100 richest people using Python, providing a step-by-step guide to create a log/log space plot.

Understanding the Data

The dataset consists of the net worths of the top 100 richest people in the world. This information is often available from financial news outlets and wealth-tracking websites. For the purpose of this demonstration, assume we have this data in a list where each value represents an individual’s net worth in billions of dollars.

Here’s a sample from the data:

Why Log/Log Space?

A log/log plot is particularly useful for data that spans several orders of magnitude, as it does with the world’s wealthiest individuals. This type of plot can help to linearize exponential relationships, making it easier to identify patterns that might not be apparent in a linear plot. For wealth distributions, which often follow a power law, log/log plots can highlight the underlying distribution’s scale-free nature.

Preparing for the Plot

Before plotting, ensure you have Python installed on your system along with the necessary libraries: Matplotlib for plotting and NumPy for numerical operations.

If you haven’t already, you can install these libraries using pip:

pip install matplotlib numpy

The Python Script

First, import the necessary libraries:

import matplotlib.pyplot as plt
import numpy as np

Assuming you have the net worth data in a list named net_worths in billions of dollars, you can prepare your data.

For ease of reproducibility, I’ll include my list at the point of writing here:

net_worths_float = [
    234.0, 156.0, 155.0, 126.0, 125.0, 124.0, 118.0, 117.0, 116.0, 116.0,
    87.8, 84.6, 82.4, 74.3, 72.6, 70.6, 69.6, 67.8, 63.2, 61.7, 61.6, 59.4,
    50.5, 50.5, 42.3, 41.3, 41.3, 40.0, 39.9, 39.1, 38.8, 37.0, 36.1, 36.0,
    35.2, 35.1, 34.2, 32.9, 32.0, 31.9, 31.9, 31.5, 30.1, 29.5, 29.3, 29.2,
    28.9, 28.5, 28.0, 27.9, 27.9, 27.7, 27.3, 27.1, 26.6, 26.5, 26.5, 25.9,
    25.1, 23.9, 23.9, 23.4, 23.2, 23.2, 23.0, 22.6, 22.3, 22.1, 21.8, 21.6,
    21.5, 21.5, 21.4, 21.4, 21.3, 21.2, 20.6, 20.6, 20.4, 20.3, 19.9, 19.7,
    19.6, 19.1, 19.0, 18.9, 18.8, 18.8, 18.5, 18.5, 18.5, 18.5, 18.4, 17.7,
    17.6, 17.6, 17.5, 17.2, 17.2, 17.2
]

If your data isn’t sorted, sort it in descending order:

net_worths = sorted(net_worths, reverse=True)

Next, create a rank for each individual based on their position in the sorted list. The richest person gets rank 1, the second richest gets rank 2, and so on:

ranks = np.arange(1, len(net_worths) + 1)

Plotting the Data

Now, you’re ready to plot the data in log/log space:

plt.figure(figsize=(10, 6))
plt.loglog(ranks, net_worths, marker='o', linestyle='-', color='b')
plt.xlabel('Rank (log scale)')
plt.ylabel('Net Worth in Billions (log scale)')
plt.title('Net Worth of the Top 100 Richest People (Log/Log Space)')
plt.grid(True, which="both", ls="--")
plt.show()

This code snippet will generate a log/log plot of the net worths. The loglog function from Matplotlib is used to automatically scale both axes to a logarithmic scale. Markers are added for each point to clearly delineate the individual net worths, and a grid is added for better readability.

Interpreting the Plot

In the resulting plot, each point represents an individual’s net worth plotted against their rank. A straight line in a log/log plot indicates a power law distribution, common in wealth distributions and many natural phenomena. The slope of this line (if it appears roughly straight) can give you the power law’s exponent, offering deeper insights into the inequality of wealth distribution.

This visualization technique is not just limited to financial data; it can be applied to any dataset that spans multiple orders of magnitude and is suspected to follow a power law or similar distribution. Whether you’re a data scientist, economist, or simply a curious observer, plotting data in log/log space can unveil patterns and relationships that are not immediately visible in traditional linear plots.

Follow Up Analysis

For instance, you can examine the cumulative net worth as people are sampled from this distribution:

Also, check out our Finxter article:

8 Millionaire Tips to Reach Financial Freedom as a Coder

The post Visualizing Wealth: Plotting the Net Worth of the World’s Richest in Log/Log Space appeared first on Be on the Right Side of Change.

import matplotlib.pyplot as plt

# Data
x = [1, 2, 3, 4]
y = [1, 4, 9, 16]

# Plotting the line with a specific color, e.g., 'red'
plt.plot(x, y, color='red')

# Displaying the plot
plt.show()

In this minimal code example, plt.plot(x, y, color='red') creates a line plot of x versus y, with the line color set to red. You can replace 'red' with other color names like 'blue', 'green', etc., or use color codes (e.g., '#FF5733' for a specific shade of orange).

Let’s explore Matplotlib’s amazing color functionality further!

Understanding Matplotlib Colors

Basic Colors in Matplotlib

Matplotlib is a popular data visualization library in Python, and colors play a crucial role in making these visualizations informative and visually appealing. With the right choice of colors, you can emphasize certain aspects of your data and make your plots more interpretable. In Matplotlib, you have access to a wide range of built-in colors to work with.

Some of the basic colors in Matplotlib are red, green, blue, cyan, magenta, yellow, black, and white. These colors can be specified in a variety of ways, such as by their names or using RGB and RGBA values.

Here are some examples of how you can define colors in Matplotlib:

• By name: 'red', 'blue', 'green'
• By RGB values: (0.5, 0.2, 0.8)
• By RGBA values: (0.5, 0.2, 0.8, 0.5)

Matplotlib Recognizes Colors

Matplotlib recognizes different formats to specify colors, which provides flexibility for you when customizing your visualizations. Transparency can also be added to these colors using the alpha value of an RGBA color.

Here’s a brief overview of some ways to specify colors in Matplotlib:

• Named colors: E.g., 'coral', 'seagreen', 'royalblue'.
• Hex color codes: E.g., '#FF5733', '#4D5656'.
• RGB tuples: E.g., (0.5, 0.8, 0.4).
• RGBA tuples: E.g., (0.2, 0.7, 0.9, 0.6).

Working with RGB and Hex Colours

RGB to Hex Conversion

When working with colors in matplotlib, you might need to convert RGB values to Hex format. RGB colors are defined by a tuple of three values corresponding to the red, green, and blue components. For example, an RGB value can be represented as (0.1, 0.2, 0.5). To convert RGB colors to Hex values, you can use the matplotlib.colors.to_hex function. Here’s an example:

import matplotlib.colors as mcolors

rgb_color = (0.1, 0.2, 0.5)
hex_color = mcolors.to_hex(rgb_color)
print(hex_color)
# #1a3380

This code snippet will convert the RGB color (0.1, 0.2, 0.5) into its corresponding Hex value '#1A3380'.

Specifying Colors in RGB and Hex

In matplotlib, you can specify colors using both RGB and Hex values. When specifying colors as RGB or RGBA (red, green, blue, alpha) tuples, make sure to use float values in the closed interval [0, 1]. For example, you can use (0.1, 0.2, 0.5) for an RGB color or (0.1, 0.2, 0.5, 0.3) for an RGBA color with alpha transparency.

On the other hand, to specify colors in Hex format, use a string representing the hex RGB or RGBA value (e.g., '#0f0f0f' for an RGB hex color or '#0f0f0f80' for an RGBA hex color). The Hex string is case-insensitive.

Here’s a simple example of how to create a scatter plot while specifying colors in RGB and Hex formats:

import matplotlib.pyplot as plt

# Example data
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

# Specifying colors in RGB and Hex
colors = [
    (0.1, 0.2, 0.5),  # RGB color
    '#FF5733',        # Hex color
    (1, 0, 0, 0.5),   # RGBA color
    '#0f0f0f80'       # RGBA Hex color
]

# Creating a scatter plot
for i, color in enumerate(colors):
    plt.scatter(x[i], y[i], color=color, label=color)

plt.legend()
plt.show()

Output:

Using Named Colors and XKCD Colors

In matplotlib, you have access to a wide range of named colors and XKCD colors to create visually appealing and informative plots.

Named colors are predefined colors with unique names, making it convenient for you to apply them in your plots. You can use basic color names such as 'blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'black', and 'white'. Matplotlib library also supports a more extensive set of named colors, allowing you to choose from over 1200+ options. To work with named colors, simply use their names as the color parameter in your plot.

XKCD colors were introduced based on a user survey conducted by the webcomic XKCD. These colors offer an even more diverse palette, with almost 95 of the 148 X11/CSS4 color names making an appearance in the XKCD color survey. Note that the color values for the X11/CSS4 and XKCD palettes may differ, with only 'black', 'white', and 'cyan' being identical.

When creating your plots, you can combine both named and XKCD colors to enhance visual appeal:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2*np.pi)
y = np.sin(x)

# Using named color
plt.plot(x, y, color='blue')

# Using XKCD color
plt.plot(x, y, color='xkcd:sea green')

plt.show()

Remember, when using XKCD colors, prefix the color name with 'xkcd:', as in 'xkcd:gray'.

Explore and experiment with various named colors and XKCD colors in your matplotlib plots to customize them according to your needs. Choosing the right color combination not only makes your plots visually pleasing but also helps in conveying the information more effectively to your audience.

Delving into Colormaps

Standard and Custom Colormaps

In Matplotlib, you have access to a wide variety of built-in colormaps that can be easily utilized for visualizing your data. Some popular colormaps include viridis, plasma, and inferno. To use a colormap, simply import the matplotlib.cm module as cm and then choose from the available colormaps.

import matplotlib.cm as cm
custom_colormap = cm.viridis

However, sometimes you may want to create a custom colormap that matches your specific needs. In this case, you can create your own colormap using the LinearSegmentedColormap.from_list() method. It requires a list of RGB tuples, defining the mixture of colors from 0 to 1.

from matplotlib.colors import LinearSegmentedColormap

colors = [(0, 0, 1), (0, 1, 1), (1, 1, 0), (1, 0, 0)]
custom_colormap = LinearSegmentedColormap.from_list("my_colormap", colors)

Hot and Cold Colormaps

A special subset of colormaps, known as hot and cold colormaps, are particularly useful when visualizing data with temperature-like values. These colormaps help to emphasize the contrast between low and high values in your data. Examples of hot colormaps are hot, autumn, and YlOrRd. Cold colormaps include cool, winter, and PuBu.

When working with numpy arrays (np), you can easily apply a colormap to your data. By first normalizing your data, you ensure that the colormap maps to the full range of values in your dataset.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap

colors = [(0, 0, 1), (0, 1, 1), (1, 1, 0), (1, 0, 0)]
custom_colormap = LinearSegmentedColormap.from_list("my_colormap", colors)

data = np.random.rand(10, 10)
norm_data = (data - data.min()) / (data.max() - data.min())

fig, ax = plt.subplots()
im = ax.imshow(norm_data, cmap=custom_colormap)
plt.colorbar(im)
plt.show()

Matplotlib Pyplot and Its Color Utilities

Aqua and Other Unique Colors in Pyplot

Matplotlib provides a diverse selection of colors, including unique ones like Aqua. You can easily incorporate these colors into your plots to make them more visually appealing.

For instance, you can set an Aqua-colored line in your plot by specifying c='aqua' as a keyword argument when plotting with plt.plot(). You’ll find that it’s simple to experiment with different colors and create visually striking charts to enhance your data visualization.

Working with Labels and Titles

Adding labels and titles is essential to provide context and improve the readability of your plots. With Matplotlib’s pyplot (usually imported as plt), you can easily add titles and labels to your plots. To set a title for your plot, use the plt.title() function and pass in a string that describes the main topic of the plot. For example, plt.title("My Aqua-colored Line Plot") will display a title at the top of the plot.

Use plt.xlabel() and plt.ylabel() functions to label the x-axis and y-axis respectively. Provide a string describing the quantities being plotted along each axis, and the labels will appear next to the corresponding axis.

Color Specification Conversions in Matplotlib

In Matplotlib, you can easily convert colors between different formats using built-in functions to ensure consistent handling of colors throughout your visualizations. Here are some of the key functions for color specification conversions:

• to_rgba: This function allows you to convert a color or sequence of colors to RGBA format. It accepts a variety of input color formats (e.g., string, RGB tuple, or RGBA tuple), and normalizes the resulting RGBA values to a range of 0 to 1.
• to_rgba_array: Like the to_rgba function, this one converts a set of colors to RGBA format, but it does so for an entire array of colors in a single step. This is particularly useful when you’re working with colormaps or a large collection of colors.
• rgb_to_hsv: This function allows you to convert a set of RGB colors to the hue, saturation, and value (HSV) color space. This conversion can be useful for creating custom colormaps or color functions that take advantage of the HSV representation, which can be more intuitive when dealing with color palettes.

Here’s an example of using these color conversion functions in your code:

import matplotlib.colors as mcolors

# Convert a single color to RGBA format
color_rgba = mcolors.to_rgba('blue')

# Convert a list of colors to an RGBA array
color_list = ['red', 'green', 'blue']
color_rgba_array = mcolors.to_rgba_array(color_list)

# Convert a list of RGB colors to HSV format
rgb_colors = [(1, 0, 0), (0, 1, 0), (0, 0, 1)]
hsv_colors = mcolors.rgb_to_hsv(rgb_colors)

By understanding and utilizing these color specification conversion functions in Matplotlib, you can achieve greater control over your data visualizations and ensure that your colors are represented consistently across various color formats.

Manipulating CSS4 and Tableau Colors

Introduction to CSS4 Colors

With Matplotlib, you can tap into the power of CSS4 colors to enhance your data visualizations. CSS4 colors are a standardized set of over 140 named colors that can be used in web design, and they are also available in Matplotlib for creating vibrant and meaningful plots.

To use CSS4 colors, simply refer to the color by its name (case-insensitive) when specifying a color for a plot. For example:

import matplotlib.pyplot as plt

plt.plot([1, 2, 3], [4, 5, 6], color='darkorchid')
plt.show()

This code snippet will generate a line plot with a darkorchid color. By exploring the list of named CSS4 colors, you can find the perfect color for your visualization needs.

Understanding Tableau Colors

Tableau is a powerful data visualization tool that offers its own set of colors, known as the Tableau palette. The Tableau color palette is designed to be visually appealing and colorblind-friendly. In Matplotlib, you can access the Tableau colors by applying the tableau-colorblind10 style:

import matplotlib.pyplot as plt

plt.style.use('tableau-colorblind10')

Once you have applied this style, Matplotlib will use the colors from the Tableau palette automatically for your plots. If you need to access a specific color from the palette, you can create a dictionary of Tableau colors using their index positions:

tableau_colors = {
    0: '#1f77b4',
    1: '#ff7f0e',
    2: '#2ca02c',
    3: '#d62728',
    4: '#9467bd',
    5: '#8c564b',
    6: '#e377c2',
    7: '#7f7f7f',
    8: '#bcbd22',
    9: '#17becf'
}

color = tableau_colors[0]  # Access the first tableau color

Working with Grayscale and Transparency

Grayscale in Matplotlib

In Matplotlib, you can easily work with grayscale images. To display an image in grayscale, you can employ the imshow() function. When reading an image using the PIL (Python Imaging Library) library, you can convert it to grayscale with the convert("L") method.

For example:

from PIL import Image
import matplotlib.pyplot as plt

image = Image.open(file).convert("L")
plt.imshow(image, cmap="gray")
plt.show()

This code snippet will display the image in grayscale using the gray color map.

Transparency and Alpha Channel

Transparency is another useful feature to work with in Matplotlib. The alpha channel determines the transparency level of an element. Alpha values range from 0 (completely transparent) to 1 (completely opaque).

You can set the alpha values for various elements, such as text, lines, or patches. For example, when creating a plot with a semi-transparent orange rectangle, you can adjust the alpha value:

import matplotlib.patches as patches

rect = patches.Rectangle((0.5, 0.5), 1, 1, linewidth=1, edgecolor='r', facecolor='orange', alpha=0.8)
ax.add_patch(rect)
plt.show()

In this example, the orange rectangle’s transparency is controlled by setting the alpha parameter to 0.8. Remember to keep your plots clear and understandable when using transparency with different elements.

Using Matplotlib to Create Scatter Plots and Colorbars

In this section, we will discuss how you can use Matplotlib to create scatter plots and colorbars in your data visualizations. By the end of this section, you will be able to confidently create scatter plots and colorbars using the Matplotlib library.

Creating Scatter Plots

Scatter plots are widely used to visualize the relationships between two continuous data features. With Matplotlib, creating a scatter plot is as simple as using the scatter() function. For example, to create a basic scatter plot with random data points, you can use the following code:

import numpy as np
import matplotlib.pyplot as plt

x = np.random.rand(100)
y = np.random.rand(100)

plt.scatter(x, y)
plt.show()

But what if you want to display multiple sets of data points, each with a different color? You can simply call the scatter() function multiple times before plt.show() and set the color parameter to a color of your choice:

plt.scatter(x1, y1, color='red')
plt.scatter(x2, y2, color='blue')

Find more details on creating different scatter plots here.

Building Colorbars

Colorbars help in conveying additional information about your data points by assigning colors based on a third variable or their value. To create colorbars with your scatter plot, you need to set the c parameter in the scatter() function, which represents the data points’ colors, and then use the colorbar() function:

import numpy as np
import matplotlib.pyplot as plt

x = np.random.rand(100)
y = np.random.rand(100)

c_values = np.random.rand(100)
plt.scatter(x, y, c=c_values, cmap='viridis')
plt.colorbar()
plt.show()

In the above example, the colors are set according to the c_values array, using the chosen colormap viridis. You can find more details on adding colorbars to your scatter plots here.

Frequently Asked Questions

How do I specify a color in Matplotlib using RGB?

To specify a color using RGB values in Matplotlib, you can use the tuple format (r, g, b), where r, g, and b are floating-point numbers between 0 and 1 representing the intensity of red, green, and blue, respectively. For example:

plt.plot(x, y, color=(0.5, 0.2, 0.8))

This will create a plot with a custom color that has 50% red, 20% green, and 80% blue.

What are the default color cycles in Matplotlib?

Matplotlib uses a default color cycle that is applied to plot elements like lines, markers, and labels. The default cycle includes the following colors, specified with single character shorthand:

• b: blue
• g: green
• r: red
• c: cyan
• m: magenta
• y: yellow
• k: black
• w: white

These colors will be used in the order specified when plotting multiple elements in a single plot.

How do I convert a hex color to RGB in Matplotlib?

In Matplotlib, you can convert a hex color to RGB by using the matplotlib.colors.hex2color function. Here’s an example:

import matplotlib.colors as mcolors
hex_color = "#32a852"
rgb_color = mcolors.hex2color(hex_color)

This will convert the hex color #32a852 to its corresponding RGB tuple (0.196, 0.658, 0.322).

How can I create a custom color map in Matplotlib?

To create a custom color map in Matplotlib, you can use the matplotlib.colors.LinearSegmentedColormap class. First, define a dictionary that maps the color channel (red, green, or blue) to a list of segments. Each segment is a tuple with three values: (x, y1, y2), where x is a position between 0 and 1, and y1 and y2 are color intensities. Here’s an example:

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
cmap_data = {
    'red': [(0.0, 0.0, 0.0), (1.0, 1.0, 1.0)],
    'green': [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0)],
    'blue': [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0)],
}
custom_cmap = mcolors.LinearSegmentedColormap('my_cmap', cmap_data)

This will create a custom color map that transitions from black to red.

What are the available color palettes in Python?

There are several color palettes available in Python, mainly provided by libraries like Matplotlib and Seaborn. In Matplotlib, you can access a comprehensive list of named colors that includes color names from the CSS specification, X11 colors, and more. In Seaborn, you have access to a variety of color palettes such as qualitative, sequential, and diverging. You can use these palettes in either library, or even create your own custom palettes to suit your needs.

How do I use color names in Matplotlib plots?

Matplotlib supports using color names directly in your plot code. To utilize a color by its name, simply provide the name as a string for the color parameter when plotting. Here’s an example:

plt.plot(x, y, color='darkviolet')

This will create a plot with a line colored in darkviolet.

The post Matplotlib Colors: A Comprehensive Guide for Effective Visualization appeared first on Be on the Right Side of Change.

This is one of the projects you will likely come across as a data analyst. How do you go about solving this problem? No doubt, you will ask your client for more information. For example, data showing previous years’ commission payments, the number of sales representatives, and the company’s defined formula for calculating commissions.

For this project, we assumed that the only information at our disposal is a rate schedule showing the company’s formula for calculating commissions.

Rates Schedule

The table shows that the more sales, the higher the commission rate. Since we were neither given sales historical data nor the number of sales representatives, we are going to make a few assumptions.

Basic Assumptions

We will generate  random sales data based on the following assumptions which are also based on the information from the rates schedule:

1. Sales made cannot be below 1000 dollars.
2. Sales made are in thousands.
3. The company employed 500 persons for the affiliate marketing program.
4. Sales made by each individual cannot be more than 1 million dollars in a given year.

With these assumptions, we are ready to generate random data.

Python’s random module is used to generate random numbers. We will use the sample() method which takes in a range of numbers and generate random data based on the length defined.

The parameters for the range() function are given as: range(start, stop, step) where:

1. start: The starting point. In our case, it is 1000 as we assumed that the sales amount cannot be below 1000 dollars.
2. stop: The ending point. In our case, it is 1 million. We assumed that it won’t go beyond that.
3. step: The number to skip to ensure that the data end with three zeros as given in the rates schedule.

The sample() method takes another parameter that indicates the length of the random numbers. Remember that each randomly generated number represents the sales made by each individual. So, the length will be 500 to indicate the number of workforces employed by the company.

import random

sales = random.sample(range(1000, 1000000, 1000), 500)

Let’s load the data on a Pandas DataFrame.

import pandas as pd

data = pd.DataFrame({'Sales': sales})

data
0    986000
1    451000
2    487000
3    982000
4    194000
..      ...
495  761000
496  615000
497  786000
498  952000
499   82000

[500 rows x 1 columns]

data.Sales.min()
 2000

data.Sales.max()
986000

Now that we have our sales data. The next thing we have to do is to calculate the commission. The commission amount on the other hand is based on the rates. So, we need a way to assign rates for each sales representative based on sales made. A defined function will accomplish that.

def commissionRates(sales):
    if sales <= 100000:
        return .03
    elif sales <= 500000:
        return .05
    else:
        return .1

With this function defined, we can easily create the rates column using Pandas’ apply function.

data['Rates'] = data.Sales.apply(commissionRates)
data.head(10)

       Sales   Rates
0  986000   0.10
1  451000   0.05
2  487000   0.05
3  982000   0.10
4  194000   0.05
5  305000   0.05
6  154000   0.05
7  768000   0.10
8  685000   0.10
9  885000   0.10

The rates are applied according to the rates schedule given to us. To get the commission amount, it’s a matter of multiplying the rates by the sales amount.

data['Commission'] = data.Sales * data.Rates
data.tail(10)

          Sales     Rates  Commission
490  149000   0.05      7450.0
491  793000   0.10     79300.0
492  205000   0.05     10250.0
493  894000   0.10     89400.0
494  276000   0.05     13800.0
495  761000   0.10     76100.0
496  615000   0.10     61500.0
497  786000   0.10     78600.0
498  952000   0.10     95200.0
499   82000   0.03      2460.0

We now have the total commission amount of $ 21,831,140 to be paid to sales representatives.

Monte Carlo Simulation

Monte Carlo analysis is a useful tool for making predictions. It takes as an input, different random numbers and runs them several times to generate many probable outcomes. How do we apply it in our case?

We want to predict the commission amount to be budgeted for the coming year. The amount we realized was based on one single attempt or iteration. We can’t just conclude that this is the ideal amount until we run it several times up to 10,000 or more using different randomly generated data.

def simulate_commission(iterations):
    results = []
    for i in range(iterations):
    sales = random.sample(range(1000, 1000000, 1000), 500)
    data = pd.DataFrame({'Sales': sales})
    data['Rates'] = data.Sales.apply(commissionRates)
    data['Commission'] = data.Sales * data.Rates
    results.append(
        [
        data.Sales.sum().round(),
        data.Commission.sum().round(),
        ]
    )
    
    return results

We create a function that will perform the simulation based on the number of times chosen. We can try 1,000, 10,000 or even 50,000 times. In the end, we sum the sales and the commissions to be used for further analysis.

Let’s give it a try with 5000 simulations and load it on a Pandas DataFrame.

results = simulate_commission(5000)
results = pd.DataFrame.from_records(results, columns=[‘Sales’, ‘Commission’])

results
          Sales        Commission
0     256137000  22305150.0
1     252466000  21865310.0
2     246516000  21478230.0
3     250821000  21669860.0
4     252750000  22314280.0
...         ...         ...
4995  253876000  22073200.0
4996  245326000  21089810.0
4997  248717000  21651090.0
4998  246074000  21105970.0
4999  251908000  21810780.0

results.describe().round()
                  
                  Sales   Commission
count       5000.0      5000.0
mean   250092538.0  21826489.0
std      4526122.0    523127.0
min    229959000.0  19379090.0
25%    247034250.0  21476432.0
50%    250058000.0  21816840.0
75%    253203250.0  22188120.0
max    266212000.0  23649430.0

After running 5000 simulations, the results show that the commission amount is between $19M and $23M with a mean of $21M. This is within our previous results. Let’s visualize this on a histogram.

def currency(x, pos):
    if x >= 1e6:
        s = '${:1.1f}M'.format(x*1e-6)
    else:
        s = '${:1.0f}K'.format(x*1e-3)
    return s

Here, we are setting the function that will format the commission amount as it’s too large to be fitted on the chart. It will take the amount and the tick position as parameters. We will feed it into the xaxis.set_major_formatter() method to format the string.

import matplotlib.pyplot

fig, ax = plt.subplots()

ax.xaxis.set_major_formatter(currency)

results.Commission.plot(kind='hist', title='Commission Amount')

plt.grid()
plt.show()

Running the simulation 10,000 times produced the following result which is almost similar to the previous one.

The mean is still between $21M and $22M, and the commission payment ranges between $19M and $24M.

These results no doubt give the managers of the retail outlet an estimate of how much should be budgeted for commission payment for the following year.

Conclusion

We solved a real-world problem using Monte Carlo simulation – a tool used to gain a better understanding of distributions of probable outcomes. By calculating a formula multiple times using different random inputs, management can be able to make informed decisions.

This demonstration gives you an idea of how you can apply Monte Carlo simulation to solve more advanced problems.

The post How I Solved a Real-World Problem Using Monte Carlo Simulation appeared first on Be on the Right Side of Change.

Well, Google Bard to the rescue!

Reverse Engineer Exponential Plot in 2D

First, let’s try a simple exponential curve.

Input Image:

I passed this chart along with the following prompt in Google Bard:

 Prompt: Reverse engineer the code leading to this graphic

So Google Bard suggests the following code to generate the graph in Python.

Bard Output Code:

import matplotlib.pyplot as plt
import numpy as np

def exponential_function(x):
  return np.exp(x)

x_values = np.linspace(0, 10, 100)
y_values = exponential_function(x_values)

plt.plot(x_values, y_values)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Exponential Curve')
plt.show()

This code from Google Bard generates the following chart.

Insane! Google Bard figured out the exact exponential curve by looking at the input chart.

This is really advanced if you think about it. I was particularly impressed by the fact that Bard even got the function right leading to the chart — not only the rough code to plot a similar chart.

So if you needed one more proof of the deep intelligence of large language models (LLMs) that’s way beyond the trivial probabilistic prediction of the next word or character, here it is.

Let’s try another more complex (higher-order) curve:

Reverse Engineer Higher-Order Curve

Now let’s use a higher-order cubic function plot and pass it into Google Bard to see if it can generate the code that produces it.

Input Image:

 Prompt: Give me the code leading to this output

Google Bard spits out the following code.

Bard Output Code:

import matplotlib.pyplot as plt
import numpy as np

# Create the data
x = np.linspace(-10, 10, 100)
y = x**2

# Plot the data
plt.plot(x, y)

# Add a title
plt.title('Plot of a Higher-Order Function')

# Add labels to the axes
plt.xlabel('X')
plt.ylabel('f(x)')

# Show the plot
plt.show()

This yields the following image:

Some things are correct, such as the x-axis and the labels. Other things are incorrect or imprecise such as the y-axis and the plot — even though it figured out that it’s a higher-order function.

3D Normal Distribution

Next, I tried a more complex 3D plot of a multivariate normal distribution. You can read my blog tutorial on how to do this here.

Recommended: How to Plot a 3D Normal Distribution in Python?

This is the image I passed into Google Bard.

Input Image:

And the Bard prompt:

 Prompt: Reproduce the code that generates the image

Bard Output Code:

import plotly.graph_objects as go

fig = go.Figure(data=[go.Cone(
    x=[1, 2, 3],
    y=[1, 2, 3],
    z=[1, 2, 3],
    u=[1, 2, 3],
    v=[1, 1, 2],
    w=[4, 4, 1],
    showscale=False,
    hoverinfo="u+v+w+name",
)])

fig.update_layout(
    title="3D Cone Plot",
    scene=dict(
        camera=dict(
            eye=dict(x=-1.57, y=1.36, z=0.58),
        ),
        domain=dict(x=[0, 1]),
    ),
)

fig.show()

When I run the code, I get the following output:

Fail.

While it captures that the plot is generated with Python and it contains a 3D plot (out of all things possible), it doesn’t produce the correct plot in that case.

Putting It Together

I’m very impressed with Google Bard’s capabilities, and I’m sure they will grow significantly over the next couple of months. Google Bard can already match the capabilities of an entry-level data scientist.

Soon you’ll be able to pass screenshots of arbitrary plots into it and let it generate the code for you. This is six-figure-per-year work currently done by advanced data scientists.

When I was still a researcher at University, I’d have done almost everything for such a tool — given that most research papers live and die by the high-quality plots they generate and most researchers and data scientists spend huge amounts of time figuring out how others have generated their stunning-looking plots.

Recommended: Google Bard Extracts Code From Images (PNG, JPEG, WebP)

The post Towards Reverse Engineering Matplotlib Code From Images appeared first on Be on the Right Side of Change.

Here’s the code for copy and paste. I also added comments to explain what each part is doing:

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import multivariate_normal
from mpl_toolkits.mplot3d import Axes3D

# define parameters for x and y distributions
mu_x = 0  # mean of x
variance_x = 3  # variance of x

mu_y = 0  # mean of y
variance_y = 15  # variance of y

# define a grid for x and y values
x = np.linspace(-10, 10, 500)  # generate 500 points between -10 and 10 for x
y = np.linspace(-10, 10, 500)  # generate 500 points between -10 and 10 for y
X, Y = np.meshgrid(x, y)  # create a grid for (x,y) pairs

# create an empty array of the same shape as X to hold the (x, y) coordinates
pos = np.empty(X.shape + (2,))

# fill the pos array with the x and y coordinates
pos[:, :, 0] = X  
pos[:, :, 1] = Y  

# create a multivariate normal distribution using the defined parameters
rv = multivariate_normal([mu_x, mu_y], [[variance_x, 0], [0, variance_y]])

# create a new figure for 3D plot
fig = plt.figure()

# add a 3D subplot to the figure
ax = fig.add_subplot(projection='3d')

# create a 3D surface plot of the multivariate normal distribution
ax.plot_surface(X, Y, rv.pdf(pos), cmap='viridis', linewidth=0)

# set labels for the axes
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')

# display the 3D plot
plt.show()

Interactive: I also created a Google Colab Jupyter Notebook where you can plot it yourself. Click here to open it in a new tab.

I went ahead and tried to anticipate some follow-up questions you may have on the code. Here they are:

FAQ

1. What is a multivariate normal distribution? This concept from probability theory and statistics extends the 1D normal distribution to multiple dimensions. The code uses a 2D or bivariate normal distribution.
2. What does np.linspace(-10, 10, 500) do? This function generates 500 evenly spaced points from -10 to 10 over the interval. It’s used here to create a range of values for x and y. I have written a detailed blog tutorial here (with video).
3. What is np.meshgrid(x, y) used for? This function generates a two-dimensional grid of coordinates based on two one-dimensional arrays. In this case, it generates a grid of (x, y) pairs.
4. What is the purpose of the pos array? The pos array is used to hold the coordinates of each point in the grid in a format suitable for use with the multivariate_normal probability density function. It’s a 3D array where the first two dimensions match the dimensions of the grid, and the third dimension has size 2 to hold the x and y coordinates.
5. What does rv.pdf(pos) do? This function calculates the value of the probability density function (pdf) of the multivariate normal distribution at each point in the grid.
6. What is plot_surface used for? This function is used to create a three-dimensional plot of the distribution. It takes as input the x and y coordinates and the pdf values at each point, generating a 3D surface plot.
7. What is the purpose of 'cmap' parameter in the plot_surface function? The ‘cmap‘ parameter is used to specify the color map for the plot. 'viridis' is one of the predefined color maps in Matplotlib.
8. Why is the covariance matrix diagonal? The covariance matrix is diagonal because the variables x and y are assumed to be independent in this bivariate distribution. Off-diagonal elements of the covariance matrix represent the covariance between different variables – these are zero if the variables are independent.
9. What does linewidth=0 do? The linewidth parameter in plot_surface specifies the line width for the edges of the surface polygons. Setting it to 0 removes these edges.

Feel free to check out our full course on Matplotlib on the Finxter academy.

Academy: Matplotlib – The Complete Guide to Becoming a Data Visualization Wizard

The post How to Plot a 3D Normal Distribution in Python? appeared first on Be on the Right Side of Change.

import matplotlib.pyplot as plt
import numpy as np


X = np.array([1, 2, 3])
Y = np.array([1, 2, 3])
Z = np.array([1, 2, 3])

fig = plt.figure()
ax = fig.gca(projection='3d')
surface = ax.plot_surface(X, Y, Z, linewidth=0, antialiased=False)

plt.show()

The output when running this code is as follows

Warning (from warnings module):
  File "C:\Users\xcent\Desktop\code.py", line 10
    ax = fig.gca(projection='3d')
MatplotlibDeprecationWarning: Calling gca() with keyword arguments was deprecated in Matplotlib 3.4. Starting two minor releases later, gca() will take no keyword arguments. The gca() function should only be used to get the current axes, or if no axes exist, create new axes with default keyword arguments. To create a new axes with non-default arguments, use plt.axes() or plt.subplot().
Traceback (most recent call last):
  File "C:\Users\xcent\Desktop\code.py", line 11, in <module>
    surface = ax.plot_surface(X, Y, Z, linewidth=0, antialiased=False)
  File "C:\Users\xcent\AppData\Local\Programs\Python\Python39\lib\site-packages\matplotlib\_api\deprecation.py", line 431, in wrapper
    return func(*inner_args, **inner_kwargs)
  File "C:\Users\xcent\AppData\Local\Programs\Python\Python39\lib\site-packages\mpl_toolkits\mplot3d\axes3d.py", line 1658, in plot_surface
    raise ValueError("Argument Z must be 2-dimensional.")
👉 ValueError: Argument Z must be 2-dimensional. 

Solution

The error message ValueError: Argument Z must be 2-dimensional. indicates that the plot_surface method requires a 2-dimensional array for the Z parameter. In the code above, I’m passing a 1-dimensional array Z = np.array([1, 2, 3]).

As for the deprecation warning, this is because the method gca() will no longer accept keyword arguments in future versions of Matplotlib, so I should use a different method to create the axes.

Here’s a modified version of your code that should work correctly. This code creates a simple 3D surface where the Z values are simply the product of the X and Y values:

import matplotlib.pyplot as plt
import numpy as np


X = np.array([[1, 2, 3]])
Y = np.array([[1], [2], [3]])
Z = X * Y

fig = plt.figure()
ax = plt.axes(projection='3d')
surface = ax.plot_surface(X, Y, Z, linewidth=0, antialiased=False)

plt.show()

In the fixed code, X, Y, and Z are all 2-dimensional arrays now. I made X and Y 2D by adding an extra set of brackets around their definitions. This creates arrays with shapes (1,3) and (3,1), respectively.

Shape Example: A 2D array with shape (1,3) is like a single row with 3 columns, containing 3 elements. An array with shape (3,1) is like 3 rows with a single column each, a tall, thin structure with 3 elements.

When multiplied to create Z, they are broadcasted into two dimensions to create a (3,3) array.

Also, instead of using gca() to create the 3D axes, I have used the plt.axes() function with the projection='3d' keyword argument, as suggested by the deprecation warning.

The post (Fix) ValueError: Argument Z must be 2-dimensional appeared first on Be on the Right Side of Change.

Here’s a code example for copy and paste:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm

# Create the X, Y, and Z coordinate arrays. 
x = np.linspace(-5, 5, 101)
y = np.linspace(-5, 5, 101)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

# Create a surface plot and projected filled contour plot under it.
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection='3d')

# Select Colormap
cmap = cm.viridis

# Norm for color mapping
norm = plt.Normalize(Z.min(), Z.max())

# Plot surface with color mapping
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, facecolors=cmap(norm(Z)), alpha=0.9, linewidth=0)

# Add a color bar which maps values to colors
m = cm.ScalarMappable(cmap=cmap, norm=norm)
m.set_array(Z)
fig.colorbar(m)

ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()

If you run this code in your Python shell, you’ll get a beautiful interactive 3D waterfall plot:

In your case you’ll probably need to replace the data with your own. Feel free to check out our guide on linspace() with video if you need some background there.

Let’s dive into the steps in the code to get this plot done next.

Step 1: Import Libraries

import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm

Here we are importing the necessary libraries. Numpy is for numerical operations, Matplotlib’s pyplot is for plotting, and cm from Matplotlib is for working with colormaps.

Step 2: Generate Data

x = np.linspace(-5, 5, 101)
y = np.linspace(-5, 5, 101)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

Here, linspace generates 101 evenly spaced points between -5 and 5 for both x and y.

You can watch our explainer video on the function here:

Recommended: How to Use np.linspace() in Python? A Helpful Illustrated Guide

The NumPy function meshgrid takes two 1D arrays representing the Cartesian coordinates in the x and y axis and produces two 2D arrays.

The Z array is a 2D array that represents our “heights” and is calculated by applying the sine function to the square root of the sum of the squares of X and Y, essentially creating a 2D sine wave.

Step 3: Prepare the Figure

fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection='3d')

We first create a figure object, and then add a subplot to it. The '111' argument means that we want to create a grid with 1 row and 1 column and place the subplot in the first (and only) cell of this grid. The projection='3d' argument means that we want this subplot to be a 3D plot.

Do you need a quick refresher on subplots? Check out our video on the Finxter blog:

Recommended: Matplotlib Subplot – A Helpful Illustrated Guide

Step 4: Prepare Colormap

cmap = cm.viridis
norm = plt.Normalize(Z.min(), Z.max())

Here we’re choosing a colormap (cm.viridis), and then creating a normalization object (plt.Normalize) using the minimum and maximum values of Z. This normalization object will later be used to map the heights in Z to colors in the colormap.

Step 5: Plot the Surface

surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, facecolors=cmap(norm(Z)), alpha=0.9, linewidth=0)

The method ax.plot_surface() plots the 3D surface.

• The arguments X, Y, Z are the coordinates for the plot.
• The rstride and cstride parameters determine the stride (step size) for row and column data respectively,
• facecolors parameter takes the colormap applied on the normalized Z,
• alpha is used for blending value, between 0 (transparent) and 1 (opaque), and
• linewidth determines the line width of the surface plot.

Step 6: Add a Color Bar

m = cm.ScalarMappable(cmap=cmap, norm=norm)
m.set_array(Z)
fig.colorbar(m)

A ScalarMappable object is created with the same colormap and normalization as our surface plot. Then we associate this object with our Z array using the set_array function. Finally, we add a color bar to the figure that represents how the colors correspond to the Z values.

Step 7: Set Labels and Show the Plot

ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()

Here, we’re setting the labels for each axis (X, Y, Z). Finally, plt.show() is called to display the plot. The plot will remain visible until all figures are closed.

Instead of using the plot.show() function to see the output, you can use the plt.savefig('output.jpeg') statement to save it in a file 'output.jpeg'.

Recommended: Matplotlib — A Simple Guide with Videos

The post How Do I Make a 3D Waterfall Plot with Colored Heights in Python? appeared first on Be on the Right Side of Change.

In this guide, I’ll show you how to put legends outside your plot for (click to jump):

• Matplotlib
• Seaborn
• Pandas
• Bokeh

Let’s start with the first!

Matplotlib Put Legend Outside Plot

Let’s start with various ways to position the legend outside for better visualization and presentation.

Matplotlib Set Legend Outside Plot (General)

First, let’s adjust the legend’s position outside the plot in general. To do this, use the bbox_to_anchor parameter in the legend function like this: matplotlib.pyplot.legend(bbox_to_anchor=(x, y)) . Here, adjust the values of x and y to control the legend’s position.

import matplotlib.pyplot as plt

# Sample data for plotting
x = [1, 2, 3, 4, 5]
y1 = [1, 4, 9, 16, 25]
y2 = [1, 8, 27, 64, 125]

# Create the plot
plt.plot(x, y1, label='y = x^2')
plt.plot(x, y2, label='y = x^3')

# Set the legend's position outside the plot using bbox_to_anchor
plt.legend(bbox_to_anchor=(1.05, 1))

# Add axis labels and title
plt.xlabel('x')
plt.ylabel('y')
plt.title('Plotting with External Legend')

# Display the plot
plt.show()

In this example, the bbox_to_anchor parameter is set to (1.05, 1), which moves the legend slightly to the right of the plot.

Info: The bbox_to_anchor parameter in matplotlib.pyplot.legend() uses a tuple of two values, x and y, to control the position of the legend. x=0/1 controls the left/right and y=0/1 controls the bottom/top legend placement.

Generally, in axes coordinates:

• (0, 0) represents the left-bottom corner of the axes.
• (0, 1) represents the left-top corner of the axes.
• (1, 0) represents the right-bottom corner of the axes.
• (1, 1) represents the right-top corner of the axes.

However, the values of x and y are not limited to the range [0, 1]. You can use values outside of this range to place the legend beyond the axes’ boundaries.

For example:

• (1.05, 1) places the legend slightly to the right of the top-right corner of the axes.
• (0, 1.1) places the legend slightly above the top-left corner of the axes.

Using negative values is also allowed. For example:

• (-0.3, 0) places the legend to the left of the bottom-left corner of the axes.
• (1, -0.2) places the legend below the bottom-right corner of the axes.

The range of x and y depends on the desired position of the legend relative to the plot. By adjusting these values, you can fine-tune the legend’s position to create the perfect visualization.

Matplotlib Set Legend Below or Above Plot

To place the legend below the plot, you can set the loc parameter as ‘upper center’ and use bbox_to_anchor like this: plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.1)). For placing the legend above the plot, use bbox_to_anchor=(0.5, 1.1) instead .

Matplotlib Set Legend Left of Plot (Upper, Center, Lower Left)

For positioning the legend to the left of the plot, use the following examples:

• Upper left: plt.legend(loc='center left', bbox_to_anchor=(-0.2, 0.5))
• Center left: plt.legend(loc='center left', bbox_to_anchor=(-0.1, 0.5))
• Lower left: plt.legend(loc='lower left', bbox_to_anchor=(-0.2, 0))

Matplotlib Set Legend Right of Plot (Upper, Center, Lower Right)

To position the legend to the right of the plot, you can try the following:

• Upper right: plt.legend(loc='upper right', bbox_to_anchor=(1.1, 1))
• Center right: plt.legend(loc='center right', bbox_to_anchor=(1.1, 0.5))
• Lower right: plt.legend(loc='lower right', bbox_to_anchor=(1.1, 0))

Matplotlib Set Subplots Legend Outside Plot

When working with subplots, you can place a single, unified legend outside the plot by iterating over the axes and using the legend() method on the last axis (source) . Remember to use the bbox_to_anchor parameter to control the legend’s position.

Here’s an example that does two things, i.e., (1) placing the legend on the right and (2) adjusting the layout to accommodate the external legend:

import numpy as np
import matplotlib.pyplot as plt

# Sample data for plotting
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# Create subplots
fig, axes = plt.subplots(nrows=2, ncols=1, sharex=True)

# Plot data on the first subplot
axes[0].plot(x, y1, label='sin(x)')
axes[0].set_title('Sine Wave')

# Plot data on the second subplot
axes[1].plot(x, y2, label='cos(x)', color='orange')
axes[1].set_title('Cosine Wave')

# Set a common x-label for both subplots
fig.text(0.5, 0.04, 'x', ha='center')

# Set y-labels for individual subplots
axes[0].set_ylabel('sin(x)')
axes[1].set_ylabel('cos(x)')

# Create a unified legend for both subplots
handles, labels = axes[-1].get_legend_handles_labels()
for ax in axes[:-1]:
    h, l = ax.get_legend_handles_labels()
    handles += h
    labels += l

# Place the unified legend outside the plot using bbox_to_anchor
fig.legend(handles, labels, loc='upper right', bbox_to_anchor=(1, 0.75))

# Adjust the layout to accommodate the external legend
fig.subplots_adjust(right=0.7)

# Display the subplots
plt.show()

Legend Outside Plot Is Cut Off

If your legend is cut off, you can adjust the saved figure’s dimensions using plt.savefig('filename.ext', bbox_inches='tight'). The bbox_inches parameter with the value ‘tight’ will ensure that the whole legend is visible on the saved figure .

Add Legend Outside a Scatter Plot

For a scatter plot, you can use the same approach as mentioned earlier by adding the loc and bbox_to_anchor parameters to position the legend outside the plot. For instance, plt.legend(loc='upper right', bbox_to_anchor=(1.1, 1)) will place the legend in the upper right corner outside the scatter plot .

If your legend is cut off when placing it outside the plot in Python’s Matplotlib, you can adjust the layout and save or display the entire figure, including the external legend, by following these steps:

1. Use the bbox_to_anchor parameter in the legend() function to control the position of the legend.
2. Adjust the layout of the figure using the subplots_adjust() or tight_layout() function to make room for the legend.
3. Save or display the entire figure, including the external legend.

Here’s an example demonstrating these steps:

import matplotlib.pyplot as plt

# Sample data for plotting
x = [1, 2, 3, 4, 5]
y1 = [1, 4, 9, 16, 25]
y2 = [1, 8, 27, 64, 125]

# Create the plot
plt.plot(x, y1, label='y = x^2')
plt.plot(x, y2, label='y = x^3')

# Set the legend's position outside the plot using bbox_to_anchor
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')

# Add axis labels and title
plt.xlabel('x')
plt.ylabel('y')
plt.title('Plotting with External Legend')

# Adjust the layout to accommodate the external legend
plt.subplots_adjust(right=0.7)

# Display the plot
plt.show()

In this example, you use the subplots_adjust() function to adjust the layout of the figure and make room for the legend.

You can also use the tight_layout() function, which automatically adjusts the layout based on the elements in the figure:

# ...
# Set the legend's position outside the plot using bbox_to_anchor
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')

# Add axis labels and title
plt.xlabel('x')
plt.ylabel('y')
plt.title('Plotting with External Legend')

# Automatically adjust the layout to accommodate the external legend
plt.tight_layout(rect=[0, 0, 0.7, 1])

# Display the plot
plt.show()

In this case, the rect parameter is a list [left, bottom, right, top], which specifies the normalized figure coordinates of the new bounding box for the subplots. Adjust the values in the rect parameter as needed to ensure the legend is not cut off.

Additional Legend Configurations

In this section, you’ll learn about some additional ways to customize the legend for your plots in Python using Matplotlib. This will help you create more meaningful and visually appealing visualizations. However, feel free to skip ahead to the following sections on plotting the legend outside the figure in Seaborn, Pandas, and Bokeh.

Python Set Legend Position

As you already know by now, you can place the legend at a specific position in the plot by using the bbox_to_anchor parameter. For example, you could place the legend outside the plot to the right by passing (1.05, 0.5) as the argument:

import matplotlib.pyplot as plt
plt.legend(bbox_to_anchor=(1.05, 0.5))

This will place the legend slightly outside the right border of the plot, with its vertical center aligned with the plot center.

Python Set Legend Location

You can easily change the location of the legend by using the loc parameter. Matplotlib allows you to use predefined locations like 'upper right', 'lower left', etc., or use a specific coordinate by passing a tuple:

plt.legend(loc='upper left')

This will place the legend in the upper-left corner of the plot.

Python Set Legend Font Size

To change the font size of the legend, you can use the fontsize parameter. You can pass a numeric value or a string like 'small', 'medium', or 'large' to set the font size:

plt.legend(fontsize='large')

This will increase the font size of the legend text.

Python Set Legend Title

If you want to add a title to your legend, you can use the title parameter. Just pass a string as the argument to set the title:

plt.legend(title='My Legend Title')

This will add the title “My Legend Title” above your legend.

Python Set Legend Labels

If you’d like to customize the legend labels, you can pass the labels parameter. It takes a list of strings as the argument:

plt.legend(labels=['Label 1', 'Label 2'])

Your legend will now display the custom labels “Label 1” and “Label 2” for the corresponding plot elements.

Python Set Legend Color

Changing the color of the legend text and lines can be achieved by using the labelcolor parameter. Just pass a color string or a list of colors:

plt.legend(labelcolor='red')

This will change the color of the legend text and lines to red.

Seaborn Put Legend Outside Plot

In this section, I’ll show you how to move the legend outside the plot using Seaborn. Let’s dive into various ways of setting the legend position, like below, above, left or right of the plot.

Sns Set Legend Outside Plot (General)

First, let’s talk about the general approach:

You can use the legend() function and the bbox_to_anchor parameter from Matplotlib to move the legend. You can combine this with the loc parameter to fine-tune the legend’s position.

Here’s a quick example:

import seaborn as sns
import matplotlib.pyplot as plt

# Sample data for plotting
tips = sns.load_dataset("tips")

# Create a Seaborn plot with axis variable 'ax'
fig, ax = plt.subplots()
sns_plot = sns.scatterplot(x="total_bill", y="tip", hue="day", data=tips, ax=ax)

# Set the legend's position outside the plot using bbox_to_anchor on 'ax'
ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)

# Add axis labels and title
ax.set_xlabel('Total Bill')
ax.set_ylabel('Tip')
ax.set_title('Tips by Total Bill and Day')

# Display the plot
plt.show()

Sns Set Legend Below or Above Plot

Now let’s move the legend below or above the plot. Simply adjust the bbox_to_anchor parameter accordingly. For example, to place the legend below the plot, you can use bbox_to_anchor=(0.5, -0.1):

ax.legend(loc='upper center', bbox_to_anchor=(0.5, -0.1))

And to place the legend above the plot, use bbox_to_anchor=(0.5, 1.1):

ax.legend(loc='lower center', bbox_to_anchor=(0.5, 1.1))

Sns Set Legend Left of Plot (Upper, Center, Lower Left)

Similarly, to position the legend on the left side of the plot, you can use the following code snippets:

Upper left:

ax.legend(loc='upper right', bbox_to_anchor=(-0.15, 1))

Center left:

ax.legend(loc='center right', bbox_to_anchor=(-0.15, 0.5))

Lower left:

ax.legend(loc='lower right', bbox_to_anchor=(-0.15, 0))

Sns Set Legend Right of Plot (Upper, Center, Lower Right)

Lastly, to place the legend on the right side of the plot, adjust the bbox_to_anchor parameter like so:

Upper right:

ax.legend(loc='upper left', bbox_to_anchor=(1.05, 1))

Center right:

ax.legend(loc='center left', bbox_to_anchor=(1.05, 0.5))

Lower right:

ax.legend(loc='lower left', bbox_to_anchor=(1.05, 0))

With these techniques, you can easily position the legend outside the plot using Seaborn! Happy plotting!

Pandas Put Legend Outside Plot

When working with Pandas and Matplotlib, you often want to move the legend outside the plot to improve readability. No worries! You can do this by taking advantage of the fact that .plot() returns a Matplotlib axis, enabling you to add .legend(bbox_to_anchor=(x, y)) to your code.

Here’s how:

First, import the necessary libraries like Pandas and Matplotlib:

import pandas as pd
import matplotlib.pyplot as plt

Create your DataFrame and plot it using the plot() function, like this:

data = {'A': [1, 2, 3], 'B': [4, 5, 6]}
df = pd.DataFrame(data)
ax = df.plot()

Next, you’ll want to place the legend outside the plot. Adjust the coordinates parameter, bbox_to_anchor, to position it according to your preferences. For example, if you want to place the legend to the right of the plot, use:

ax.legend(bbox_to_anchor=(1.05, 1))

plt.tight_layout()
plt.show()

This code will place the legend to the right of the plot, at the top .

Bokeh Put Legend Outside Plot

Placing a legend outside the plot in Bokeh can be easily done by using the add_layout method. You’ll need to create a Legend object manually and then add it to your plot using add_layout. This gives you the flexibility to position the legend anywhere on your plot, which is particularly helpful when you have many curves that might be obscured by an overlapping legend.

Here’s a short example to help you move the legend outside the plot in Bokeh:

from bokeh.plotting import figure, show
from bokeh.models import Legend, LegendItem
from bokeh.io import output_notebook
output_notebook()

# Example data
x = list(range(10))
y1 = [i**2 for i in x]
y2 = [i**0.5 for i in x]

# Create a figure
p = figure(title="Example Plot")

# Add line glyphs and store their renderer
r1 = p.line(x, y1, line_color="blue", legend_label="Line 1")
r2 = p.line(x, y2, line_color="red",  legend_label="Line 2")

# Create Legend object
legend = Legend(items=[
    LegendItem(label="Line 1", renderers=[r1]),
    LegendItem(label="Line 2", renderers=[r2])
], location="top_left")

# Add legend to plot
p.add_layout(legend, 'right')

# Show plot
show(p)

To ensure your plot is as clear as possible, we recommend experimenting with different legend positions and layouts. By customizing your plot, you can maintain a clean and organized display of your curves even when there’s a lot of information to convey.

With Bokeh, you have full control over your plot’s appearance, so enjoy exploring different options to find the perfect fit for your data!

Keep Learning With Your Python Cheat Sheet!

Feel free to download our free cheat sheet and join our tech and coding academy by downloading the free Finxter cheat sheets — it’s fun!

The post Python 🐍 Put Legend Outside Plot 📈 – Easy Guide appeared first on Be on the Right Side of Change.

To ensure they have the best possible start in life, I’ve been looking into ways to invest money to provide them with a lump sum of $70k when they reach 21. But I don’t want to spend that much money at once when they turn 21.

So what to do?

In this blog post, I’ll be exploring how Python helped me figure out a simple investment plan, so I can give my kids a nice nest egg without needing to spend a lot of our (parents’) money at once.

Result: I need to set up a savings plan contributing $90 per month for 21 years in a vehicle earning 9% per year (e.g., S&P500 ETF), so my kids get a $70k nest egg when they start into their own lives.

Here’s the Python code — I’ll explain it in a moment:

import matplotlib.pyplot as plt
import numpy as np

# Define initial investment value, investment return, and monthly contributions
initial_investment = 1000
investment_return = 0.09
monthly_contributions = [30,60,90]
num_years = 21

# Create list of portfolio values over time for each savings rate
portfolio_values = []
for contribution in monthly_contributions:
    portfolio = [initial_investment]
    portfolio_value = initial_investment
    for i in range(1,num_years-1):
        portfolio_value = portfolio_value * (1 + investment_return) + contribution * 12
        portfolio.append(portfolio_value)
    portfolio_values.append(portfolio)

# Plot portfolio values over time
time = np.arange(1,num_years)
for i in range(len(monthly_contributions)):
    plt.plot(time, portfolio_values[i], label='$' + str(monthly_contributions[i]) + '/m')
plt.title('Portfolio Value over Time')
plt.xlabel('Time (years)')
plt.ylabel('Portfolio Value ($)')

# Add end value labels
for i in range(len(monthly_contributions)):
    plt.text(num_years-3, portfolio_values[i][-1], '$' + str(int(portfolio_values[i][-1]*1.3)))

plt.legend()
plt.show()

Result:

This code snippet plots the value of a portfolio for different monthly contributions over a period of 21 years.

You specify the

• initial investment value,
• investment return,
• number of years, and
• monthly contributions.

Then, you create a list to store the portfolio values over time for each monthly contribution.

You calculate the portfolio values by multiplying the previous value of the portfolio by the investment return plus the contribution for each month. You repeat this calculation over the number of years minus one, taking the initial investment into account.

You use Matplotlib to plot the portfolio values. The x-axis is the time in years and the y-axis is the portfolio value in dollars.

Recommended Tutorial: A Video Guide on Matplotlib

You add a title and labels to the plot. You also add the end value for each of the portfolios to the plot with a text label. Finally, you display the plot.

Action Steps

• Copy the code into your own Python script.
• Figure out your (base) investment goals for your kids or yourself. What do you need to accomplish? What would be your dream outcome?
• Change the input values until you’re happy with your results.

You can check out our Finxter Academy course on Matplotlib to learn all you need to use plotting and data visualization in Python.

This is part of our 100 practical Python projects series. Subscribe here.

By the way, Finxter Mark came up with this clever script that is kind of a generalization of the previous code snippet. Very nicely done!

# A program from the 100 Projects for 2023 Series at Finxter.com
# 6 January 2023

import matplotlib.pyplot as plt
import numpy as np

'''Get the initial values from the user
for the plots.  Initial investment, return rate, contributions (number of them for plot)
'''
# Define initial investment value, investment return, and monthly contributions

initial_investment = int(input('Initial Invest: '))
investment_return = float(input('Return Rate (ex 0.03): '))

# creating an empty list
monthly_contributions = []

# number of elements as input
n = int(input("Enter number of different monthly contribution amounts: "))

# iterating till the range
for i in range(0, n):
    # grab the elements and append, let user know which one we are on of the set
    ele = int(input('Contribution amount ' + str(i+1) + ': '))
    monthly_contributions.append(ele)  # adding the element

num_years = int(input('Years: '))



# Create list of portfolio values over time for each savings rate
portfolio_values = []
for contribution in monthly_contributions:
    portfolio = [initial_investment]
    portfolio_value = initial_investment
    for i in range(1,num_years-1):
        portfolio_value = portfolio_value * (1 + investment_return) + contribution * 12
        portfolio.append(portfolio_value)
    portfolio_values.append(portfolio)

# Plot portfolio values over time
time = np.arange(1,num_years)
for i in range(len(monthly_contributions)):
    plt.plot(time, portfolio_values[i], label='$' + str(monthly_contributions[i]) + '/m')
plt.title('Portfolio Value over Time')
plt.xlabel('Time (years)')
plt.ylabel('Portfolio Value ($)')

# Add end value labels
for i in range(len(monthly_contributions)):
    plt.text(num_years-2, portfolio_values[i][-1], '$' + str(int(portfolio_values[i][-1]*1.3)))

plt.legend()
plt.show()

Here’s an example run of the flexible scripts with three kids investing $1000 in a lump sum (each) and $50, $100, and $200 monthly contributions for 20 years:

The post Strategic Investing with Python: Ensuring Your Kids Have $70k at 21 appeared first on Be on the Right Side of Change.