# How to Make a Circular Color Gradient in Python

Using Python to create a circular color gradient is an effective technique for eye-popping data visualizations that are informative and visually appealing. You can create gradients that are both visually appealing and easy to understand with the appropriate set of colors and parameters. But what’s the need?

Circular color gradients are a popular visualization technique in data science, machine learning, and image processing. They are a great way to represent continuous data on a circular surface and can add visual interest to your plots. Additionally, mastering the art of creating circular color gradients in Python can give you an edge in the world of data visualization, as it is a skill that is highly sought after by employers and clients alike.

So, are you also interested in making a circular gradient of colors in Python but have no idea where to begin? Worry not.

In this detailed guide, we will show you an easy and precise step-by-step method for making circular color gradients in Python

Let’s get into it.

## How to Make a Circular Color Gradient in Python – Step-By-Step Explanation

Let’s first look at a complete Python Code example for creating a circular color gradient using Matpotlib Library.

### Example Code.

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

# Define color map
colors = [(1, 0, 0), (1, 1, 0), (0, 1, 0), (0, 1, 1), (0, 0, 1), (1, 0, 1), (1, 0, 0)]
cmap = LinearSegmentedColormap.from_list("my_cmap", colors)

center = (0, 0)

# Create meshgrid for plotting
x = np.linspace(-1, 1, 500)
y = np.linspace(-1, 1, 500)
X, Y = np.meshgrid(x, y)
dist = np.sqrt((X - center)**2 + (Y - center)**2)

# Create figure and plot gradient
fig, ax = plt.subplots(figsize=(6, 6))
ax.imshow(rgba_gradient, extent=[-1, 1, -1, 1], aspect='equal')

ax.patch.set_alpha(0.5)
ax.set_xlim([-1, 1])
ax.set_ylim([-1, 1])
ax.set_xticks([])
ax.set_yticks([])
ax.set_facecolor((0, 0, 0))

plt.show()``````

### Step By Step Explanation

Let’s analyze the code and describe each step thoroughly.

• Changed `aspect='auto'` to `aspect='equal'` to make sure the plot is a perfect circle.
• Removed `ax.xaxis.set_visible(False)` and `ax.yaxis.set_visible(False)` and used `ax.set_xticks([])` and `ax.set_yticks([])` instead to hide the axis ticks and labels.
• Changed `ax.set_facecolor('black')` to `ax.set_facecolor((0, 0, 0))` to set the background color as black using an RGB tuple.
• Removed `ax.set_alpha(0.5)` as `ax.patch` controls the transparency of the background.

### Choosing a Color Palette for the Gradient

You need to select a color palette to make a circular color gradient. A color palette is a set of colors to display data in a chart. Matplotlib has pre-made color maps like “viridis”, “inferno”, “plasma”, “magma”, and “cividis” that can be used to make color gradients. You can create a custom color palette by defining RGB values.

In our example, we created a custom color palette with seven RGB values that go from red to violet.

`colors = [(1, 0, 0), (1, 1, 0), (0, 1, 0), (0, 1, 1), (0, 0, 1), (1, 0, 1), (1, 0, 0)]`

Next, we need to determine the midpoint and size of the gradient. The gradient’s center is the main point where it is centered, and the radius determines how much the colors extend from the center. We set the center at (0, 0) and the radius to 1 in our example.

`center = (0, 0)`

`radius = 1`

### Creating a color map using the matplotlib library:

Once we have defined the color palette, we can create a color map using the ` LinearSegmentedColormap function` from the `matplotlib.colors` module. This function takes a list of colors and returns a colormap object that can be plotted.

In the example code above, we create a color map object called cmap using the `LinearSegmentedColormap.from_list()` method. We pass in the name we want to give to our colormap (“`my_cmap`“) and the list of colors we defined earlier.

### Creating a circular gradient using matplotlib.

Now that we have made the color map, we can plot the circular gradient. The code example starts by making a 2D point grid using `np.meshgrid()`. We use the Pythagorean theorem to find the distance of each point from the centre of the grid, which is calculated as `R = np.sqrt(X**2 + Y**2).`

We use the pcolormesh() function from matplotlib.pyplot to plot the circular gradient. We also provide the grid’s X and Y coordinates, the calculated radius R, and the previously defined cmap object. Next, we use the `axis()` function to ensure the plot has an equal aspect ratio.

### Animating the gradient using matplotlib and animation:

The gradient can be animated using the FuncAnimation class from the matplotlib.animation module. The plot is updated for each animation frame using a function provided to the FuncAnimation class.

The code below has an update function called `update(frame)` that slightly changes the color map object cmap by rotating the list of colors. Next, we make a FuncAnimation instance using the figure, update function, and desired number of frames for animation.

#### Example Code

``````import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap
from matplotlib.animation import FuncAnimation

# Define color palette
colors = [(1, 0, 0, 0), (1, 1, 0, 0.5), (0, 1, 0, 0.5), (0, 1, 1, 0.5), (0, 0, 1, 0.5), (1, 0, 1, 0.5), (1, 0, 0, 0)]

# Create color map
cmap = LinearSegmentedColormap.from_list("my_cmap", colors, N=256)

# Create 2D grid of points
X, Y = np.meshgrid(np.linspace(-1, 1, 100), np.linspace(-1, 1, 100))

# Calculate distance from center of grid
R = np.sqrt(X**2 + Y**2)

fig, ax = plt.subplots(figsize=(5, 5))
mesh = ax.pcolormesh(X, Y, R, cmap=cmap)
ax.axis("equal")
plt.show()

# Animate the gradient using matplotlib and animation
def update(frame):
"""
Function to update the color map for each frame of the animation
"""
angle = frame/10.0
colors = [(1, 0, 0, 0), (1, 1, 0, 0.5), (0, 1, 0, 0.5), (0, 1, 1, 0.5), (0, 0, 1, 0.5), (1, 0, 1, 0.5), (1, 0, 0, 0)]
new_colors = np.roll(colors, int(angle))
cmap = LinearSegmentedColormap.from_list("my_cmap", new_colors, N=256)
mesh.set_cmap(cmap)
return mesh,

ani = FuncAnimation(fig, update, frames=100, interval=50, blit=True)
plt.show()``````

The first step, as explained before, is to import the required libraries and define the color palette for the gradient. A color map is made with the LinearSegmentedColormap function from the matplotlib.colors module.

Afterward, a grid of points with two dimensions is made using the np.meshgrid function from the NumPy library. Then, the distance between each point and the center of the grid is found using the np.sqrt function.

The pcolormesh function from the matplotlib.pyplot module is used to plot the circular gradient. You can use the axis function to make the plot have an equal aspect ratio.

The plot now has animation using the FuncAnimation class from the matplotlib.animation module. The update function changes the color map object for each animation frame. The frames and interval arguments control how many frames there are and how much time is between each frame.