Accelerate Your Scientific Writing: Integrating Python with LaTeX#

1.1 LaTeX in a Nutshell#

LaTeX is a typesetting system widely used for scientific and technical documents. Developed by Leslie Lamport, it is built on top of the TeX typesetting engine by Donald Knuth. LaTeX features:

• Precise control of layout (fonts, spacing, margins)
• Easy management of references, equations, figures, tables
• High-quality mathematical typesetting

When you write a LaTeX document, you give special commands in the .tex file, which is then compiled into a PDF or other formats, ensuring consistent, professional-looking output.

1.2 Python Overview#

Python is a high-level, interpreted language that has become a standard tool in scientific computing and data analysis, with libraries such as NumPy, SciPy, Matplotlib, Pandas, and more. Key reasons for Python’s popularity:

• Readable syntax, making it accessible to beginners and experts
• Large community and robust ecosystem of scientific libraries
• Cross-platform and open-source

1.3 The Synergy Between Python and LaTeX#

Individually, Python and LaTeX are extremely powerful. Combined, they provide a pipeline where:

• Python performs computations (e.g., numeric simulations, data plots).
• LaTeX displays high-quality text, math, images, and references.

Embedding Python directly into LaTeX helps:

• Automate plots and tables without manual copy-paste.
• Keep experiments reproducible: you can run Python code on the fly to update results.
• Integrate code listings and syntax highlighting with minimal effort.

Ultimately, this integration can save a significant amount of time for you and your collaborators.

2.1 Reproducible Research#

In modern research, reproducibility is crucial. By integrating Python scripts or references directly within your LaTeX document, you ensure that anyone reading the document (or any future version of you) can regenerate the exact figures, tables, and results, using the same code that produced them.

2.2 Rapid Iteration on Complex Documents#

When a revision demands changes in graphs or computations, it can be laborious to regenerate them manually in Python, then embed them again in LaTeX. An integrated workflow can make these steps seamless: update the Python code, compile the LaTeX, and see the changes instantly.

2.3 Error Reduction#

Manual copy-paste often introduces human error. An integrated approach means you are letting your scripts speak directly to your document. Fewer manual steps reduce the possibility of introducing typos, outdated results, or mismatched figure labels.

2.4 Enhanced Collaboration#

If you are working with colleagues who also use Python and LaTeX, you can share a single repository that encapsulates both the code and the text in one place. This fosters a more cohesive environment for collaboration and revision control.

3.1 Installing Python#

You can download Python from the official website (python.org). However, for scientific computing, many recommend installing a distribution such as Anaconda, which provides Python along with most of the scientific libraries you may need (NumPy, Pandas, Matplotlib, etc.).

3.2 Installing LaTeX#

Common environment distributions include:

• TeX Live (cross-platform)
• MiKTeX (Windows, macOS)
• MacTeX (macOS)

These distributions come with a large set of LaTeX packages, including the ones we will use for integration with Python.

3.3 Editors and IDEs#

Though you can write .tex files in any text editor, a specialized LaTeX editor can increase productivity. Popular choices:

• TeXstudio
• TeXworks
• Visual Studio Code with LaTeX extensions
• Overleaf (online environment)

For Python, you can use any environment: Jupyter Notebooks, Python scripts, or integrated development environments such as PyCharm, VS Code, or Spyder.

3.4 Recommended Packages#

There are multiple ways to integrate Python and LaTeX. Two of the most popular solutions are:

1. minted �?primarily for code listings with syntax highlighting.
2. pythontex �?runs Python scripts and integrates the results back into the document.

We will illustrate both approaches throughout this guide.

4.1 Generating Plots and Diagrams Externally#

The simplest approach is to generate everything in Python outside of LaTeX, then include in your .tex file. For example, you might:

1. Run a Python script to produce a .pdf or .png figure with Matplotlib.
2. Include it in LaTeX with the \includegraphics command.

Placeholder example (in Python):

1
import matplotlib.pyplot as plt
2
import numpy as np
3

4
x = np.linspace(0, 2*np.pi, 100)
5
y = np.sin(x)
6

7
plt.figure(figsize=(6,4))
8
plt.plot(x, y, label='Sine Wave')
9
plt.title('Simple Plot')
10
plt.xlabel('x')
11
plt.ylabel('sin(x)')
12
plt.legend()
13
plt.savefig('sine_plot.png', dpi=300)
14
plt.close()

Then in LaTeX:

1
\documentclass{article}
2
\usepackage{graphicx}
3

4
\begin{document}
5
\begin{figure}[h]
6
    \centering
7
    \includegraphics[width=0.5\textwidth]{sine_plot.png}
8
    \caption{A simple sine wave plot generated by Python.}
9
    \label{fig:sine}
10
\end{figure}
11
\end{document}

While straightforward, this is not a fully automated pipeline—any time you change the code, you must regenerate the plot externally. Nevertheless, it establishes a baseline workflow that is appropriate for smaller, infrequently-changing documents.

4.2 Manually Including Code#

If you simply wish to show lines of code in your LaTeX document, the default LaTeX verbatim environment can suffice:

1
\begin{verbatim}
2
import numpy as np
3
print("Hello, World!")
4
\end{verbatim}

This shows the code, but without syntax highlighting. For more professional results, minted (or other listing packages) is recommended.

5.1 Installation#

Ensure you have Pygments installed (pip install Pygments) and include minted in your LaTeX preamble:

1
\usepackage{minted}

When compiling your LaTeX document, you often need to enable -shell-escape (or --shell-escape) in your LaTeX compiler command so minted can call Pygments. For example:

1
pdflatex -shell-escape main.tex

5.2 Basic minted Usage#

Inside your LaTeX, you might write:

1
\begin{minted}{python}
2
import numpy as np
3

4
def my_function(x):
5
    return x**2
6
\end{minted}

This will highlight Python code with colorful syntax. minted also allows inline code highlighting:

1
Some text containing \mintinline{python}{x**2} inline.

5.3 Customizing minted#

minted comes with multiple options to change styling, line numbers, fonts, background, etc. For example:

1
\begin{minted}[frame=single, bgcolor=lightgray, linenos]{python}
2
import numpy as np
3

4
def my_function(x):
5
    return x**2
6
\end{minted}

Experiment with minted’s parameters for the best look that matches your document’s style.

6.1 Installation and Setup#

Include the following in your preamble:

1
\usepackage{pythontex}

Then compile in two steps (or more) because pythontex must first collect your Python code, execute it, and then inject results back into your LaTeX:

1. pdflatex -shell-escape main.tex
2. pythontex main.tex
3. pdflatex -shell-escape main.tex

Check your LaTeX editor or build system’s documentation on how to set up a multi-step compile process.

6.2 Basic pythontex Example#

Below is a minimal example:

1
\documentclass{article}
2
\usepackage{pythontex}
3

4
\begin{document}
5

6
Here is some inline Python calculation:
7
\py{2 * 3}
8
which appears in the document as 6.
9

10
\begin{pyblock}
11
x = 10
12
y = x**2
13
print(f"x = {x}, and x^2 = {y}")
14
\end{pyblock}
15

16
\end{document}

Explanation:

• \py{2 * 3} runs the Python code 2 * 3 and inserts the result (6) into the document.
• \begin{pyblock}...\end{pyblock} runs multiple lines of Python and prints the output directly in the LaTeX.

6.3 Incorporating Figures#

You can also generate figures (e.g., Matplotlib plots) within pythontex blocks, then reference them:

1
\begin{pycode}
2
import numpy as np
3
import matplotlib.pyplot as plt
4

5
x = np.linspace(0,10,100)
6
y = np.sin(x)
7

8
plt.plot(x, y, label="Sine")
9
plt.legend()
10
plt.savefig('py_sine.png')
11
plt.close()
12
\end{pycode}
13

14
\begin{figure}[h]
15
    \centering
16
    \includegraphics[width=0.5\textwidth]{py_sine.png}
17
    \caption{Plot generated by pythontex.}
18
\end{figure}

Each time you recompile, pythontex re-executes the code and updates the figure.

6.4 Tables from Data#

Suppose you have data from a numerical simulation and want to place its summary in a LaTeX table. With pythontex, you can do:

1
\begin{pycode}
2
import numpy as np
3

4
data = np.random.randn(5,2)
5
# data array with 5 rows, 2 columns
6
\end{pycode}
7

8
\begin{table}[h]
9
\centering
10
\begin{tabular}{cc}
11
\hline
12
Column 1 & Column 2 \\
13
\hline
14
\pyc{
15
for row in data:
16
    print(f"{row[0]:.3f} & {row[1]:.3f} \\\\")
17
}
18
\hline
19
\end{tabular}
20
\caption{Randomly generated data values.}
21
\end{table}

pythontex intercepts calls to \pyc{...}, runs the Python code inside, and inserts the result as raw LaTeX content. This is a powerful way to produce dynamic tables.

7.1 Standard Approach#

One recommended workflow is to keep the data analysis in Python scripts or Jupyter notebooks, then produce stable figure files (PNG, PDF, or EPS). Insert them into LaTeX documents with \includegraphics. This approach keeps the compile time of your LaTeX document lean, and you can store or version-control the final figures.

7.2 On-the-Fly Generation#

If your figures are heavily parameterized or constantly changing, pythontex provides a dynamic alternative—figures can be regenerated every time. For small figure sets, this may be ideal. For large or computationally intensive figure generation, you might prefer an offline approach to avoid lengthy compile times.

7.3 Example with Automated Sizing#

Let’s say you want a figure with an automatically determined size:

1
\begin{pycode}
2
import numpy as np
3
import matplotlib.pyplot as plt
4

5
x = np.linspace(-5,5,100)
6
y = np.exp(-x**2)
7

8
plt.figure(figsize=(4,3))
9
plt.plot(x, y, color='red')
10
plt.title("Gaussian")
11
plt.savefig('gaussian.png')
12
plt.close()
13
\end{pycode}
14

15
\begin{figure}[h]
16
    \centering
17
    \includegraphics[width=0.4\textwidth]{gaussian.png}
18
    \caption{Dynamically created Gaussian plot.}
19
\end{figure}

8.1 Best Practices for Notebook Exports#

• Keep your notebook clean, removing extraneous or exploratory cells before exporting.
• Use consistent figure sizing or rely on level-of-detail to ensure your final PDF looks professional.
• If you want to combine Jupyter code with broader text or multiple chapters, consider converting smaller notebooks (for each analysis) into LaTeX pieces and compile them within a master .tex file.

9.1 Example Makefile#

Below is a simplistic example of a Makefile that runs pythontex:

1
all: main.pdf
2

3
main.pdf: main.tex
4
  pdflatex -shell-escape main.tex
5
  pythontex main.tex
6
  pdflatex -shell-escape main.tex
7

8
clean:
9
  rm -f *.aux *.log *.out *.pyg *.pytxcode *.pytxpyg main.pdf

Then run:

1
make

This automates the multi-step build. You can expand it to handle BibTeX, index creation, and more.

9.2 Continuous Integration#

For a CI pipeline on GitHub, for example, you might have a .github/workflows/latex.yml file that:

1. Checks out your repository.
2. Installs TeX Live and Python.
3. Runs make or your custom build command.
4. Uploads the PDF artifact.

This is particularly beneficial for large collaborations or for documents that frequently require updates. Everyone sees the final PDF from a guaranteed reproducible environment.

11.1 Limit Complexity Where Possible#

Python embedded in LaTeX can be awesome, but also can overcomplicate your workflow if you are not careful. For large computations, consider using external scripts or notebooks. Keep the final integration step relatively lightweight.

11.2 Document Your Dependencies#

So that collaborators (or your future self) know how to compile your document, maintain a short “Build Instructions�?section. That might mention Python version, required packages (pip install lines), and LaTeX distribution versions. In a repository, a requirements.txt or environment.yml (for conda) can help reproducibility.

12.1 Custom Python LaTeX Macros#

You can define custom LaTeX macros that run Python code. For instance:

1
\newcommand{\pyinline}[1]{\py{#1}}

Then in your text, you might do:

1
The result of 10 factorial is \pyinline{import math; math.factorial(10)}.

This keeps your LaTeX document cleaner and offers a more streamlined appearance.

12.2 Integrating Pandas DataFrames#

Chunks of code can transform data frames into tables or summary statistics. For example:

1
\begin{pycode}
2
import pandas as pd
3

4
df = pd.read_csv('experiment_data.csv')
5
mean_val = df['measurement'].mean()
6
std_val = df['measurement'].std()
7
\end{pycode}
8

9
The average measurement is \py{mean_val:.2f} with a standard deviation of \py{std_val:.2f}.

This is powerful for large data sets where you need real-time calculations displayed in your final document.

12.3 Machine Learning Results#

Imagine if your LaTeX document needs results from a machine learning model, such as accuracy or confusion matrices. With pythontex, you can:

1. Load a trained model or re-train it during compile (time-consuming but possible).
2. Print out performance metrics directly into the LaTeX.
3. Generate plots (e.g., ROC curves, learning curves) and embed them immediately.

12.4 Generating Automatic Summaries#

If your paper includes a set of results from multiple experiments, Python can loop through them, generate aggregated charts, and print out a final table of means, standard deviations, or p-values. This fosters a fully dynamic approach: the document is always consistent with the code outputs.

12.5 Customizing minted for Specific Languages#

minted supports dozens of languages besides Python. If you are writing about multi-language systems or want to highlight JSON configurations, minted is flexible:

1
\begin{minted}{json}
2
{
3
  "key": "value",
4
  "list": [1, 2, 3]
5
}
6
\end{minted}

For scientific writing, focusing on Python is typical, but minted makes it easy to highlight any code language in your document.