# Scientific Python Lectures: a notebook course for engineers who need NumPy, SciPy and SymPy

> The jrjohansson/scientific-python-lectures repository is a set of nine IPython notebooks covering NumPy, SciPy, Matplotlib, SymPy, C and Fortran integration, HPC and revision control, with a PDF build driven by a Makefile. It is a teaching artefact, not a library, and the README is the only install documentation.

**jrjohansson/scientific-python-lectures** — Lectures on scientific computing with python, as IPython notebooks.

- Repository: https://github.com/jrjohansson/scientific-python-lectures
- Stars: 3,658 · Forks: 1,798
- Language: Jupyter Notebook
- License: not declared
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/jrjohansson-scientific-python-lectures

## What scientific-python-lectures actually is, and who it is for

The repository is a course, not a package. Its top level holds nine notebooks named Lecture-0-Scientific-Computing-with-Python.ipynb through Lecture-7-Revision-Control-Software.ipynb, a Makefile, a LaTeX source file, a chapter template, an images directory, a scripts directory, and a single data file, stockholm_td_adj.dat. There is no setup.py, no pyproject.toml, no package metadata. You cannot pip install this, and the README never suggests you can.

The audience is narrow and specific: someone who already writes code and wants a guided pass through the scientific Python stack. Lecture-1 covers Python programming itself, Lecture-2 NumPy multidimensional arrays, Lecture-3 SciPy algorithms, Lecture-4 Matplotlib 2D and 3D plotting, Lecture-5 SymPy symbolic algebra. Lectures 6A and 6B move to Fortran and C integration and to HPC. Lecture-7 is about revision control. A beginner with no programming background would find Lecture-1 thin as a first exposure; an experienced engineer will find Lectures 2 through 5 the useful part.

The README describes the work as "Lectures on scientific computing with python, as IPython notebooks". Note the vocabulary: IPython notebooks, not Jupyter notebooks. That naming survives in the README's primary instruction and in the nbviewer links, and it is the first sign of how old the framing is.

## How the notebooks, the Makefile and the PDF fit together

There are two delivery paths, and they are independent.

The first is interactive. You download the notebook files to a directory and start a notebook server from that directory. The README's command is ipython notebook, with a fallback: if you see the error `[TerminalIPythonApp] WARNING | File not found: u'notebook'`, the README says to install Jupyter and run jupyter notebook instead. That error string is the README's own way of admitting the original command has aged out.

The second path is the PDF. Scientific-Computing-with-Python.pdf sits at the top level, and Scientific-Computing-with-Python.tex is its LaTeX source. The Makefile regenerates both from the notebooks. It defines a NOTEBOOKS variable listing all nine files, a LATEXFILES variable derived by substituting .tex for .ipynb, and a pattern rule that converts each notebook with jupyter nbconvert --to latex --template chapter. The all target depends on latexfiles and buildpdf; buildpdf runs pdflatex on Scientific-Computing-with-Python.tex. The template file chapter.tplx is what nbconvert consumes.

That is the whole architecture. Notebooks are the source of truth, LaTeX is an intermediate, PDF is the artefact. There is no test suite, no rendered HTML build, and no CI configuration in the repository listing. If a notebook stops executing, nothing in the repository will tell you.

## Running the lectures locally: install and first use

The README gives no install section beyond the Jupyter link, so the honest sequence is: clone, install Jupyter, start the server, then open a notebook.

Clone the repository and change into it. The README's instruction is to download the files to a directory and run the server from that directory.

```bash
git clone https://github.com/jrjohansson/scientific-python-lectures.git
cd scientific-python-lectures
```

Install Jupyter if you do not have it. The README points at the Jupyter installation instructions and gives this as the command that replaces the old IPython entry point.

```bash
jupyter notebook
```

A browser page opens listing the notebooks in the directory. Open Lecture-2-Numpy.ipynb first; it is the point where the course stops being about Python syntax and starts being about arrays.

The PDF route uses the Makefile directly. The all target converts every notebook to LaTeX and then runs pdflatex.

```bash
make all
```

If you only want the LaTeX intermediates, the latexfiles target loops over $(NOTEBOOKS) and calls nbconvert on each one. Expect a pdflatex run to need more than one pass on a document this long; the Makefile invokes it once, so cross-references in a fresh build may not resolve until you run it again by hand. The README does not document this, and the Makefile does not loop.

## Where the course shows its age: no environment file, no pins, no CI

The most consequential limitation is that nothing in the repository records which versions of NumPy, SciPy, Matplotlib or SymPy the notebooks were written against. There is no requirements.txt, no environment.yml, no lockfile. The notebooks are the only record, and they are prose-plus-code, not a specification. If a Matplotlib API has been renamed since the notebooks were authored, you will discover it as a traceback in a cell, not as a documented incompatibility.

The README's own fallback instruction is the second signal. It tells you that `ipython notebook` may fail with a file-not-found warning and that you should move to `jupyter notebook`. The README was patched for that breakage rather than rewritten around it, which is a reasonable thing to do and also a marker of how long the text has been in circulation.

The third limitation is scope. Lecture-7 is titled Revision Control Software. That is a topic adjacent to scientific computing, not part of it, and it is the kind of material that dates fastest and matters least to someone who already uses git. If you are adopting this as a curriculum, that lecture is the one to drop or replace.

Finally, the repository is not archived, and the last push was on 2026-06-02. That is recent enough that the repository is not abandoned, but a push date tells you nothing about whether the notebooks still execute against a current scientific Python stack. Nothing in the repository claims they do.

## SciPy Lecture Notes and the difference in approach

The obvious comparison is the SciPy Lecture Notes, the community-maintained successor project in the same space. The difference is not just content coverage; it is the build model.

Scientific-python-lectures treats notebooks as the primary artefact. You read them in a browser, execute them cell by cell, and the PDF is a byproduct generated by nbconvert and pdflatex. The course is something you run.

SciPy Lecture Notes are written as reStructuredText sources that are built into HTML and PDF. The published output is the primary artefact, and the notebooks, where they exist, are generated from the source rather than being the source. The practical consequence for a reader is that the SciPy Lecture Notes are easier to read without a Python environment and easier to keep consistent across formats, while this repository gives you cells you can edit and re-run in place.

Neither approach is strictly better. If your goal is to hand students something they execute and modify, notebook-first is the right shape. If your goal is a reference document that stays readable and buildable, source-first is. The repository here made the first choice, and it commits to it: the Makefile's entire job is turning notebooks into a PDF, not the reverse.

## Licence, redistribution and the cost of keeping a fork alive

The README states that the work is licensed under a Creative Commons Attribution 3.0 Unported License, with a link to creativecommons.org/licenses/by/3.0/. The repository metadata does not carry a licence identifier, so the README text is the only licence statement available. CC BY 3.0 is an attribution licence: redistribution and adaptation are permitted provided attribution is given. That is a permissive position for a teaching repository, and it is the reason the PDF can circulate freely.

What it does not settle is the licence status of the bundled data file, stockholm_td_adj.dat, or of anything in the images directory. The README's licence paragraph covers "this work" without enumerating files. If you plan to redistribute the notebooks or the PDF inside a course pack, that ambiguity is the thing to check before you ship, and it is a question for whoever owns the material, not for a licence summary.

Upgrade cost is the real ongoing expense. Because there is no dependency manifest, every time you refresh the Python environment under a fork, you are re-validating nine notebooks by hand. The Makefile will tell you when nbconvert fails; it will not tell you when a cell produces a different plot or a numerically different answer. There are no releases in the repository, so there is no version to pin against and no changelog to read before you pull.

## Conclusion

Adopt this if you are teaching or self-studying the scientific Python stack and want a free, notebook-native course you can run locally or read as a PDF. Do not adopt it as a dependency, a maintained library, or a source of current best practice: the README documents no version pins, no CI and no rollback path, and the last push was on 2026-06-02. Verify first that the notebooks execute under your installed Jupyter and Python versions, starting with Lecture-2-Numpy.ipynb, and confirm the CC BY 3.0 attribution requirement before you redistribute the PDF or any notebook.

## FAQ

### Is scientific-python-lectures difficult to learn from?

The course opens with Lecture-1-Introduction-to-Python-Programming.ipynb, so it assumes no prior Python, but the notebooks move quickly into NumPy, SciPy and SymPy. A reader with some programming experience will get more from it than a complete beginner.

### What is Python used for in science in these lectures?

The notebooks cover NumPy multidimensional arrays, SciPy scientific algorithms, Matplotlib 2D and 3D plotting, SymPy symbolic algebra, and Fortran and C integration for HPC work. That is the scope the README lists across Lectures 1 through 6B.

### How do I run the scientific-python-lectures notebooks?

Download the notebook files to a directory and run jupyter notebook from that directory; the README notes that ipython notebook may fail with a file-not-found warning, in which case you install Jupyter and use the jupyter command instead. A browser page then lists the available notebooks.

### How do I build the scientific-python-lectures PDF?

The Makefile's all target converts every notebook to LaTeX with jupyter nbconvert --to latex --template chapter and then runs pdflatex on Scientific-Computing-with-Python.tex. The repository also ships a prebuilt Scientific-Computing-with-Python.pdf at the top level.

### What licence applies to scientific-python-lectures?

The README states the work is licensed under a Creative Commons Attribution 3.0 Unported License. The repository metadata does not carry a licence identifier, and the README does not enumerate which files the licence covers.

## Sources

- [Issues](https://github.com/jrjohansson/scientific-python-lectures/issues)
- [jrjohansson/scientific-python-lectures on GitHub](https://github.com/jrjohansson/scientific-python-lectures)
- [README](https://github.com/jrjohansson/scientific-python-lectures/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jrjohansson-scientific-python-lectures