How to create publication-ready figures and tables with Python?

Creating publication-ready figures and tables is essential for academic research and data presentation. Python, with its robust ecosystem of libraries, offers a wide range of tools to help you generate high-quality, aesthetically pleasing, customizable images for your research papers.

In this article, we will explore how to use Python to generate ready to publish figures and tables. We will cover popular libraries like Matplotlib, born in the sea, plotand pandas to create shapes and how to use them. pandas and Matplotlib to format tables. We'll also discuss important design principles and tips for optimizing these elements for publication.

Overview of publish-ready figure and table libraries

1. Matplotlib

Matplotlib is one of the most used data visualization libraries in Python. It offers extensive control over all aspects of a figure, from its size and layout to its colors and fonts. Researchers can customize their arguments to suit the requirements of their publication, ensuring that visual elements are consistent and clear.

• Key Features:
  • Detailed control over plot elements.
  • Extensive support for 2D plotting (line graphs, scatter graphs, bar graphs, etc.).
  • High flexibility to design graphics (titles, labels, axis marks).
  • You can export figures in publication-quality formats (for example, PDF, PNG, SVG).

2. Born at sea

Seaborn is based on Matplotlib and provides a higher-level interface for creating visually appealing and informative statistical plots. It simplifies the process of creating complex visualizations such as heat maps, violin plots, and regression plots, while automatically handling aesthetic elements such as color palettes and axis labels.

• Key Features:
  • Predefined themes and color palettes ideal for publish-ready graphics.
  • High-level functions for statistical graphs (e.g., box plots, pair plots, and categorical plots).
  • Seamless integration with Pandas data structures.

3. Plot

Plotly is an interactive visualization library that excels at creating highly interactive web-based charts. Although most commonly used for dashboards and web applications, Plotly's export options enable high-quality static visualizations suitable for publications. Plotly supports a wide variety of chart types, including scatterplots, choropleth maps, and 3D plots.

• Key Features:
  • Interactive visualizations (hover, zoom, and click capabilities).
  • Publication-quality static exports (e.g. PNG, SVG, PDF).
  • Wide range of graph types (e.g. choropleth maps, network graphs).
  • Easy customization of plot elements.

4. Pandas

While Pandas is primarily known for its data manipulation capabilities, it also offers robust functionality for creating simple charts and graphs. Pandas integrates seamlessly with Matplotlib and Seaborn, allowing easy conversion of DataFrames into stylish graphical plots and tables. You can export Pandas tables to HTML, LaTeX, or Excel formats, which is especially useful when preparing tables for academic articles.

• Key Features:
  • Integrated plotting functions for quick visualizations from DataFrames.
  • Ability to format tables for display (for example, setting column widths, text alignment, and borders).
  • Export options for various formats (HTML, LaTeX, Excel).

Create figures ready to publish

These are the guidelines and libraries we will use:

Key libraries

• Matplotlib– A versatile library for static, animated and interactive graphics. Allows detailed control of almost every aspect of the figure.
• born in the sea: Built on Matplotlib, Seaborn provides a high-level interface for drawing attractive statistical graphs.
• plot– For interactive visualizations, although it also supports static exports that can be used in publications.

General guidelines for figures:

• Resolution: Make sure your figures are saved in high resolution (at least 300 DPI for print quality).
• Color: Use color palettes that are easy to print and suitable for colorblind viewers.
• Readability– Use large fonts for axis labels, titles, and legends. Figures must be easily readable even at reduced sizes.
• Consistency: Keep styles consistent across all figures in the document (same font, grid lines, color schemes, etc.).
• Delete tags: Use meaningful axis labels and legends, making sure each figure is self-explanatory.

Let's create a figure with Matplotlib

import matplotlib.pyplot as plt

import numpy as np

# Create data

x = np.linspace(0, 10, 100)

y = np.sin(x)

# Create a figure with publication-quality aesthetics

plt.figure(figsize=(6, 4), dpi=300)  # Set figure size and resolution

plt.plot(x, y, label="Sine Wave", color="b", linewidth=2)

# Adding labels and title

plt.xlabel("x-axis label", fontsize=14)

plt.ylabel("Y-axis label", fontsize=14)

plt.title("Sine Wave Example", fontsize=16)

# Adding grid and legend

plt.grid(True, which="both", linestyle="--", linewidth=0.5)

plt.legend(fontsize=12)

# Saving the figure as a high-resolution PNG

plt.savefig("sine_wave_figure.png", dpi=300, bbox_inches="tight")

plt.show()

Production

Explanation

• The figsize parameter sets the dimensions of the figure (here 6×4 inches).
• The dpi = 300 ensures that the figure is high resolution.
• bbox_inches='tight' removes extra white space when saving the figure.

Also Read: Introduction to Matplotlib Using Python for Beginners

Advanced customization with Seaborn

Seaborn simplifies the creation of complex statistical graphs. It integrates with Matplotlib and can quickly generate high-quality plots with attractive default styles.

Example: a heatmap ready to publish with Seaborn

import seaborn as sns

import numpy as np

# Create a random correlation matrix

data = np.random.rand(10, 10)

# Create a heatmap with Seaborn

plt.figure(figsize=(8, 6))

sns.heatmap(data, annot=True, cmap="coolwarm", fmt=".2f", linewidths=0.5)

# Adding labels and title

plt.title("Correlation Heatmap", fontsize=16)

plt.xlabel("x-axis label", fontsize=14)

plt.ylabel("Y-axis label", fontsize=14)

# Save figure

plt.savefig("heatmap.png", dpi=300, bbox_inches="tight")

plt.show()

Production

Here, Seaborn handles much of the styling automatically (such as the color map and annotations), allowing you to focus on the data.

Also Read: The Ultimate Pandas Guide to Data Science!

Creating interactive figures with Plotly

If your publication allows interactive components (for example, supplementary materials), plot It is a powerful tool. It allows you to generate interactive graphics that can be embedded in web pages or exported as static images.

Example: Interactive Scatterplot with Plotly

!pip install --upgrade kaleido

import plotly.express as px

import pandas as pd

import numpy as np

# Sample data

df = pd.DataFrame({

   "x": np.random.randn(100),

   "Y": np.random.randn(100),

   "Category": np.random.choice(('A', 'B', 'C'), size=100)

})

# Create an interactive scatter plot

fig = px.scatter(df, x="x", y="Y", color="Category", title="Interactive Scatter Plot")

# Save as HTML file (for interactive use) or PNG (for publication)

fig.write_html("scatter_plot.html")

fig.write_image("scatter_plot.png", width=800, height=600, scale=2)

Production

Also Read: Guide to Creating Interactive Charts with Plotly Python

Tables for Publications

Tables are another crucial part of scientific articles. piton pandas The library is widely used to create and format data tables. For publication, tables must be clear, well organized and easy to read.

Example: create a table with pandas

import pandas as pd

import plotly.express as px

from IPython.core.display import HTML

# Create a DataFrame with population, continent, and country flags

data = {

   'Country': ('China', 'India', 'USA', 'Indonesia', 'Pakistan', 'Brazil', 'Nigeria', 'Bangladesh', 'Russia', 'Mexico'),

   'Population (millions)': (1444216, 1393409, 332915, 276361, 225199, 213993, 211400, 166303, 145912, 130262),

   'Continent': ('Asia', 'Asia', 'North America', 'Asia', 'Asia', 'South America', 'Africa', 'Asia', 'Europe', 'North America'),

   'Flag': (

       'https://upload.wikimedia.org/wikipedia/commons/0/0d/Flag_of_China.svg',

       'https://upload.wikimedia.org/wikipedia/commons/4/41/Flag_of_India.svg',

       'https://upload.wikimedia.org/wikipedia/commons/a/a4/Flag_of_the_United_States.svg',

       'https://upload.wikimedia.org/wikipedia/commons/9/9d/Flag_of_Indonesia.svg',

       'https://upload.wikimedia.org/wikipedia/commons/3/3f/Flag_of_Pakistan.svg',

       'https://upload.wikimedia.org/wikipedia/commons/0/05/Flag_of_Brazil.svg',

       'https://upload.wikimedia.org/wikipedia/commons/7/79/Flag_of_Nigeria.svg',

       'https://upload.wikimedia.org/wikipedia/commons/f/f9/Flag_of_Bangladesh.svg',

       'https://upload.wikimedia.org/wikipedia/commons/f/f3/Flag_of_Russia.svg',

       'https://upload.wikimedia.org/wikipedia/commons/f/fc/Flag_of_Mexico.svg'

   )

}

# Create DataFrame

df = pd.DataFrame(data)

# Manually add flags as HTML img tags (with custom width and height)

df('Flag') = df('Flag').apply(lambda x: f'x}" width="30" height="20"/>')

# Display the DataFrame using HTML rendering (to show flags correctly)

html_table = df.to_html(escape=False)  # Escape is False to allow HTML rendering

# Display the table with flags in the notebook

display(HTML(html_table))

# Map visualization using Plotly

fig = px.choropleth(df,

                   locations="Country",

                   locationmode="country names",

                   color="Population (millions)",

                   hover_name="Country",

                   hover_data=("Continent", "Population (millions)"),

                   color_continuous_scale=px.colors.sequential.Plasma,

                   title="Top 10 Countries by Population")

# Optional: To download the HTML table

from google.colab import files

df.to_html("population_table_with_flags.html", escape=False)

files.download("population_table_with_flags.html")

Best practices for tables in posts

• Use clear headings: Column headings should be descriptive and avoid overly technical jargon.
• Consistency: Make sure all numbers are presented in a consistent format (e.g. decimal places).
• Alignment: Aligns numbers by decimal points and text to the left.
• Footnotes: Use footnotes for additional explanations instead of cluttering the table.

Conclusion

Python offers a powerful set of tools for generating publish-ready figures and tables. Whether you are creating static charts with Matplotlibstatistical graphs with Seaborn or interactive visualizations with plotPython has you covered. For tables, pandas allows you to easily format and export data in various formats for publication.

Key takeaways

• Choose the appropriate libraries for the task (Matplotlib/Seaborn for static, Plotly for interactive).
• Prioritize clarity and coherence in your designs.
• Export in high resolution (300 DPI) and use readable font sizes.
• For tables, make sure you have clear headings, consistent formatting, and a clean layout.

By following these tips and using Python's extensive libraries, you can create professional-quality figures and tables that will improve the clarity and impact of your research work.

Frequently asked questions