How to plot a 3D graph in Python

Python makes 3D data visualization accessible. With libraries like Matplotlib, you can transform complex datasets into insightful three-dimensional plots that reveal patterns and relationships not visible in 2D.

In this article, you'll learn essential techniques to create and customize 3D plots. You will explore practical tips, see real-world applications, and get advice to debug your visualizations for effective graphs.

Creating a basic 3D surface plot with plot_surface()

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

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
X, Y = np.meshgrid(np.linspace(-5, 5, 50), np.linspace(-5, 5, 50))
Z = np.sin(np.sqrt(X**2 + Y**2))
surf = ax.plot_surface(X, Y, Z, cmap='viridis')
plt.show()--OUTPUT--# Output: A 3D surface plot showing a circular ripple pattern

The key to this plot is setting the projection='3d' argument when you add the subplot. This step tells Matplotlib you're creating a three-dimensional canvas rather than a standard 2D one.

With the 3D space ready, you generate the surface's coordinates. The np.meshgrid() function is crucial here; it creates the rectangular grid that the surface will be built upon. The Z values are then calculated for each point on this grid, defining the surface's height and giving it shape.

Finally, ax.plot_surface() takes the X, Y, and Z coordinate grids and renders the visualization. Adding a cmap, or colormap, helps distinguish the peaks and valleys of the plot.

Essential 3D plotting techniques

Beyond the continuous surfaces created with plot_surface(), you can also visualize your data as discrete points, wireframe structures, or contour maps.

Creating 3D scatter plots with scatter()

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

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
n = 100
ax.scatter(np.random.rand(n), np.random.rand(n), np.random.rand(n), c='blue')
plt.show()--OUTPUT--# Output: A 3D scatter plot with 100 random blue points

Scatter plots are ideal for visualizing individual data points in 3D space. Unlike surface plots, they don't connect the dots, which is perfect for showing clusters or distributions. The scatter() function is your tool for this, requiring three arrays for the x, y, and z coordinates.

• In this example, np.random.rand(n) generates 100 random points for each axis.
• The c parameter sets the color of the points—in this case, to 'blue'.

Visualizing wireframes using plot_wireframe()

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

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
X, Y = np.meshgrid(np.linspace(-3, 3, 20), np.linspace(-3, 3, 20))
Z = np.sin(X) * np.cos(Y)
ax.plot_wireframe(X, Y, Z, color='green')
plt.show()--OUTPUT--# Output: A 3D wireframe plot showing a wave-like surface

Wireframe plots give you a skeletal view of a surface, which is great for inspecting its underlying structure without a solid fill getting in the way. The plot_wireframe() function operates much like plot_surface(), using the same X, Y, and Z coordinate grids to define the shape.

• Instead of a filled-in surface, it only renders the grid lines connecting your data points.
• You can easily customize its look, for example, by setting the color parameter.

Generating 3D contour plots with contour3D()

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

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
X, Y = np.meshgrid(np.linspace(-3, 3, 50), np.linspace(-3, 3, 50))
Z = X**2 + Y**2
ax.contour3D(X, Y, Z, 50, cmap='binary')
plt.show()--OUTPUT--# Output: A 3D contour plot showing concentric circular contours

Contour plots offer a different perspective by slicing a surface at various heights. The contour3D() function draws lines where these slices intersect the surface, much like a topographical map shows elevation.

• The number passed after the Z coordinates, which is 50 in this example, sets how many contour levels to draw.
• You can control the color scheme using the cmap argument. Here, it's set to 'binary' for a simple black-and-white look.

Advanced 3D visualization methods

Beyond static plots, you can create dynamic visualizations with tools like Plotly, combine multiple 3D subplots, and define custom colormaps for greater visual impact.

Creating interactive plots with Plotly's go.Surface()

import plotly.graph_objects as go
import numpy as np

X, Y = np.meshgrid(np.linspace(-5, 5, 50), np.linspace(-5, 5, 50))
Z = np.sin(np.sqrt(X**2 + Y**2))
fig = go.Figure(data=[go.Surface(z=Z, x=X, y=Y)])
fig.show()--OUTPUT--# Output: An interactive 3D surface plot that can be rotated and zoomed

While Matplotlib is great for static images, Plotly excels at creating interactive visualizations you can explore. The setup is similar—you still generate your X, Y, and Z coordinates—but the plotting commands are unique to the library.

• You start by creating a figure object with go.Figure().
• Then, you add your data using a trace—in this case go.Surface()—which constructs the 3D shape from your coordinate grids.

The result isn't just a picture. It's a dynamic plot that you can rotate, pan, and zoom, making it much easier to analyze complex surfaces from different viewpoints.

Working with multiple 3D subplots

import numpy as np
import matplotlib.pyplot as plt

fig = plt.figure(figsize=(12, 5))
ax1 = fig.add_subplot(121, projection='3d')
ax2 = fig.add_subplot(122, projection='3d')
X, Y = np.meshgrid(np.linspace(-3, 3, 30), np.linspace(-3, 3, 30))
ax1.plot_surface(X, Y, np.sin(X), cmap='plasma')
ax2.plot_surface(X, Y, np.cos(Y), cmap='viridis')
plt.show()--OUTPUT--# Output: Two 3D surface plots side by side showing sine and cosine functions

You can display multiple 3D plots side by side by adding several subplots to a single figure. The key is the fig.add_subplot() method, which you call for each plot you want to create. The three-digit argument it takes is a shorthand for defining the layout.

• The code 121 specifies a grid of 1 row and 2 columns, and this is the 1st plot.
• Similarly, 122 places the second plot in the same grid.

Once you have your axes objects—like ax1 and ax2—you can draw on each one independently using functions like plot_surface().

Enhancing visuals with custom colormaps

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

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
X, Y = np.meshgrid(np.linspace(-3, 3, 30), np.linspace(-3, 3, 30))
Z = np.sin(X) * np.cos(Y)
surf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm, linewidth=0)
fig.colorbar(surf, shrink=0.5)
plt.show()--OUTPUT--# Output: A 3D surface plot with a coolwarm color gradient and a colorbar

Colormaps add visual depth to your plots by mapping data values to colors. You can access a wide range of predefined colormaps by importing the cm module from Matplotlib. It's a simple way to make your data more intuitive.

• In the plot_surface() function, setting cmap=cm.coolwarm applies a specific color gradient that transitions from cool to warm colors.
• Adding fig.colorbar(surf) creates a legend that shows how colors correspond to Z-values. The shrink parameter simply adjusts its size.
• Setting linewidth=0 removes the grid lines for a smoother, more continuous surface appearance.

Move faster with Replit

Replit is an AI-powered development platform that transforms natural language into working applications. You can describe what you want to build, and Replit Agent creates it—complete with databases, APIs, and deployment.

For the 3D plotting techniques covered in this article, Replit Agent can turn them into production-ready tools. You could build:

• An interactive dashboard that uses a 3D scatter() plot to visualize machine learning model clusters.
• A scientific modeling tool that generates surface plots from user-defined mathematical equations with plot_surface().
• A utility that renders topographical data as a 3D contour map for geological analysis using contour3D().

Describe your app idea, and Replit Agent will write the code, test it, and fix issues automatically, all within your browser.

Common errors and challenges

When creating 3D plots in Python, you might encounter a few common issues, but they are typically easy to resolve.

A frequent oversight is forgetting to import Axes3D from mpl_toolkits.mplot3d. Even though you don't call it directly in your code, this import is what registers the 3D projection system with Matplotlib. Without it, the library won't recognize the projection='3d' argument, and your code will fail.

Another common hurdle involves data dimensions for plot_surface(). This function specifically requires 2D arrays for the X, Y, and Z coordinates. If you pass 1D arrays, Matplotlib will raise an error because it can't construct a surface from simple lists of points.

The solution is to create a grid from your coordinate vectors. As seen in earlier examples, you can use NumPy's np.meshgrid() function to transform your 1D x and y arrays into the 2D format that plot_surface() needs.

Adding a colorbar to a 3D plot also requires an extra step that's easy to miss. You can't just call plt.colorbar() on its own. You must first capture the object returned by the plotting function, for example, surf = ax.plot_surface(...).

Once you have this object, you pass it to the colorbar method, like fig.colorbar(surf). This explicitly tells Matplotlib which plot's color mapping to display. You can then use arguments like shrink to adjust the colorbar's size relative to the plot.

Forgetting to import Axes3D for 3D plotting

This error is a classic "gotcha." Your code can look perfect, but it will fail without one specific import. Even though you don't call Axes3D directly, Matplotlib needs it to process the projection='3d' argument. The following code demonstrates this common pitfall.

import numpy as np
import matplotlib.pyplot as plt

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')  # Will raise an error
X, Y = np.meshgrid(np.linspace(-5, 5, 20), np.linspace(-5, 5, 20))
Z = X**2 + Y**2
ax.plot_surface(X, Y, Z)

The error is triggered when you set projection='3d'. Matplotlib doesn't know what this means until its 3D toolkit is registered. The following code shows how to properly initialize the environment for 3D plotting.

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D  # Required import

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
X, Y = np.meshgrid(np.linspace(-5, 5, 20), np.linspace(-5, 5, 20))
Z = X**2 + Y**2
ax.plot_surface(X, Y, Z)

The fix is a single line: from mpl_toolkits.mplot3d import Axes3D. By including this import, you register the necessary 3D toolkit, allowing Matplotlib to process the projection='3d' argument correctly. It's a silent but essential step. Make it a habit to add this import whenever you're setting up a figure for three dimensional visualization to avoid this common roadblock right from the start.

Dealing with incorrect data dimensions in plot_surface()

The plot_surface() function is strict about its inputs, requiring 2D arrays for all coordinates. A common mistake is mixing 1D and 2D arrays when defining Z values, which leads to a dimension mismatch. The following code demonstrates this error.

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

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x = np.linspace(-5, 5, 20)
y = np.linspace(-5, 5, 20)
X, Y = np.meshgrid(x, y)
Z = X**2 + y**2  # Using 1D y instead of 2D Y
ax.plot_surface(X, Y, Z)  # Will cause dimension mismatch

The problem is in the Z calculation. By using the 1D array y instead of the 2D array Y, the resulting Z array has incorrect dimensions for plot_surface(). The following code demonstrates the correct approach.

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

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x = np.linspace(-5, 5, 20)
y = np.linspace(-5, 5, 20)
X, Y = np.meshgrid(x, y)
Z = X**2 + Y**2  # Using 2D Y correctly
ax.plot_surface(X, Y, Z)

The fix is to ensure your Z calculation uses the 2D arrays, X and Y, that np.meshgrid() returns. The plot_surface() function needs a Z-value for every point on the grid, so using a 1D array in the formula breaks the structure. It's a common slip-up that happens right after creating the meshgrid. Always double-check that your Z-value formula uses the correct uppercase variables, X and Y, not the original 1D vectors.

Adding a colorbar to 3D surface plots correctly

Adding a colorbar to a 3D plot isn't as simple as calling plt.colorbar(). This function needs to know which plot to describe and where to draw the bar. Without this context, Matplotlib can't render it correctly. The code below shows this common error.

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

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
X, Y = np.meshgrid(np.linspace(-3, 3, 20), np.linspace(-3, 3, 20))
Z = X**2 + Y**2
surf = ax.plot_surface(X, Y, Z, cmap='viridis')
plt.colorbar(surf)  # Missing parameters, will cause error

The error stems from using plt.colorbar(), which struggles with 3D axes context. The fix involves calling the colorbar method on the figure object itself, explicitly linking it to the plot. The corrected code demonstrates this approach.

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

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
X, Y = np.meshgrid(np.linspace(-3, 3, 20), np.linspace(-3, 3, 20))
Z = X**2 + Y**2
surf = ax.plot_surface(X, Y, Z, cmap='viridis')
fig.colorbar(surf, ax=ax, shrink=0.5)  # Correct parameters

The key is to call the colorbar method on your figure object, like fig.colorbar(). You need to pass it the surface object, surf, so it knows which plot's color data to use. Including the ax=ax argument is also crucial; it explicitly links the colorbar to the 3D subplot, preventing errors. You can then use parameters like shrink=0.5 to adjust the colorbar's size for a cleaner look.

Real-world applications

Now that you can navigate common plotting errors, you can use these techniques to visualize everything from terrain data to climate patterns.

Visualizing terrain data with plot_surface()

You can use plot_surface() to model terrain by rendering complex mathematical equations as a visual landscape.

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

X, Y = np.meshgrid(np.linspace(-10, 10, 100), np.linspace(-10, 10, 100))
Z = 2 * np.sin(0.5 * X) + 3 * np.cos(0.7 * Y)

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
terrain = ax.plot_surface(X, Y, Z, cmap='terrain')
plt.show()

This code uses a combination of sine and cosine functions to generate a complex 3D surface. Here’s how it works:

• It starts by building the foundational X and Y coordinate grid with np.meshgrid().
• The Z-values are then calculated for each point using the formula 2 * np.sin(0.5 * X) + 3 * np.cos(0.7 * Y), creating the surface's undulating shape.

Finally, ax.plot_surface() visualizes this data. The cmap='terrain' argument applies a color gradient that helps distinguish different elevations across the plot.

Analyzing climate data with 3D scatter() plots

You can use a 3D scatter() plot to visualize how climate variables like temperature, humidity, and pressure interact, using the size and color of each point to represent a fourth variable like rainfall.

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

n_days = 50
temperature = 15 + 8 * np.random.rand(n_days)
humidity = 40 + 30 * np.random.rand(n_days)
pressure = 1000 + 10 * np.random.rand(n_days)
rainfall = 5 * np.random.rand(n_days)

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
scatter = ax.scatter(temperature, humidity, pressure, s=rainfall*20, c=rainfall, cmap='Blues')
plt.show()

This code first generates four NumPy arrays to simulate 50 days of climate data. The ax.scatter() function then places each point in 3D space using the temperature, humidity, and pressure arrays as coordinates.

• The s parameter receives the rainfall array, making each point's size dependent on the rainfall value.
• The c parameter also uses the rainfall array, assigning a color to each point based on its value, which is then interpreted by the cmap='Blues' colormap.

The result is a single plot that visualizes four distinct variables simultaneously.

Get started with Replit

Turn your new skills into a real application with Replit Agent. Try prompts like, “Build a web app that generates a 3D surface plot from a mathematical equation,” or “Create a tool that visualizes CSV data as a 3D scatter plot.”

The agent writes the code, tests for errors, and deploys your application directly from your browser. Start building with Replit.