Python Course 2026

This repository contains information about the course "Basic Programming - Introduction into Python" (2026).

Acknowledgments

In this class, we will follow largely (but not exclusively) the course NESC 3505 Neural Data Science, developed at Dalhousie University as an open educational resource.

Course structure

Approach

The first part of the course follows an inverted classroom approach, which means you prepare the material for the sessions at home, leaving the actual sessions for doing exercises, discussions, questions, and problem-solving. The second part of the course - after the vacation - consistst of more advanced sessions that will address more specific topics, such as the use of AI, data processing and presentation for neuroscience, how to design (re)usable software and such.

Schedule

Materials

The materials consist of

• Online chapters, which will provide you with the respective background
• Jupyter notebooks, in which you can learn and practice Python concepts
• YouTube videos, which go through the notebooks step-by-step. We highly recommand to try to do the notebooks first by yourself, and only use the videos if you encounter major difficulties

When indicated below, you need to read a few chapters and do the lesson part of the respective Jupyter notebooks before the session. The notebooks are divided into a lesson part, where the concepts are introduced and demonstrated, and an exercise part, where you can apply the knowledge just gained.

During the sessions, we will to the exercise parts of the notebooks together, discuss what you learned, where you encountered problems, and how to solve these.

Important: The links to chapters point at the original class material, whereas the notebooks you will find in your bwJupyter environment - as demonstrated in the first session.

Important link(s)

Link to bwJupyter environment

Feedback

Please fill out the feedback form here:

17.4. | Introduction, Setup, Project overview

To prepare before:

• Read chapters "About This Course" (all sections) and "Introduction to Data Science" (all sections)

During the class:

• Why this course? About adult learners and your motivation to learn Python, your programming/Python background, that the only way to learn to code is to write it, the importance of coding skills for science and beyond, and the use of AI tools.
• The organisation of this course. Time budget outside the classroom, videos as the last resort, and final project.
• Setting up bwJupyter.de_ and accessing the course material. How to submit exercises.
• Skills evaluation

24.04. | Variables & Assignment, Data Types & Conversion, Python Built-ins, Lists (, Dictionaries)

To prepare before:

• Read chapter "Introducing Python"; you can ignore the section Deactivate AI for Now. Also, read the next chapter with the respective learning objectives.
• On bwJupyter: Go over the notebooks 01 - Variables and Assignments to 05 - Dictionaries under __shared. Note that the exercise parts of the notebooks will be done in class.

During the class:

• Do exercises together, answer qustions.

08.05. | Dictionaries, For loops, Conditionals, pandas, Looping over datafiles

To prepare before:

• On bwJupyter: Go over the notebooks 06 - For Loops and 09 - Looping Data Files under __shared.

During the class:

• Do exercises together, answer qustions.
• For more advanced students, there will be additional, more challenging exercises (check out the extra_execises folder)

15.05. | Numpy and Scipy

To prepare before:

• On bwJupyter: Go over the notebook 08 - pandas DataFrames
• Go over the official numpy tutorial
• On bwJupyter: Go over the notebook 10 - Numpy and Scipy (no need to do the tasks, we will do them together in the class)

During the class:

• We will go through the notebook and do the tasks in the notebook

22.05. | Data Visualization using Matplotlib (1/2)

To prepare before:

• Read chapter "Introduction to Data Visualization" and the respective learning objectives.

During the class:

• We will go through the Jupyter notebook together.
• In the end, as an exercise, you should re-create a figure including different plot types based on real data

05.06. | Data Visualization using Matplotlib & Seaborn (2/2)

To prepare before:

• Do the notebook lecture from the last session on your own again
• Read chapter "Data Science Plots with Seaborn" and the respective learning objectives.

During the class:

• We will build the figures from the last session together step-by-step
• Discuss and showcase Seaborn

12.06. | IDEs and coding with AI

To prepare before:

1. An IDE (Integrated Development Environment) is a program where you have all you need to write, read, and run code effectively. We will talk about this more in the lecture, but as a preparation please try to install one very common IDE called "visual studio code": Install visual studio code here.
2. In VS code there are some very useful extensions specifically for working with Python and Jupyter notebooks. After installing VS code, go to the "Extensions marketplace" (block-like icon on the left hand pannel) and install the "Python" and "Jupyter" extensions. These extensions add helpful features, but they don't include Python itself. Note that after installing the "Python" extension, VS code may ask you somthing like "No Python found. Would you like to install uv and use it to install python?". Please only click "install" here, if it expicitly mentions "uv". If you clicked "install" you can then skip the next step.
3. UV is a piece of software that allows you to donwload Python itself as well as packages like numpy. If VS code did not offer you to install "uv", please install uv here. You will have to open either PowerShell (Windows) or Terminal (Mac/Linux) and paste the line of code for your operating system into there. Afterwards, close and open PowerShell/Terminal again and type in "uv --version", to see if it works. In the lecture we will then use uv to install python.

If this did not work for you, do not worry! At the beginning of the class, there will be some time to trouble shoot of finish installing, but it is important that you try for yourself first at home.

During the class:

• We will explain concepts like IDEs and environments.
• You will get some hands on experimence in running code on your computer and using IDEs, which will be super useful to you if you have to deal with code during your lab rotations.
• If time, we will discuss how to use AI effectively while coding and you will again get some hands on experimence in "vibe coding".

19.06. | Git(Hub)

To prepare before: Look at the slides for the session.

During the class:

• We will explain why distributed version control software like Git is useful and how it works on platforms, such as GitHub.
• You will learn to set up a simple Git repository and work with it.

Material from the class: Here are the slides and the notes from the session.

27.06. | Exploratory Data Analysis

To prepare before: Please read the following sections of the Neural Data Science course book:

• "Working with Repeated Measures": Understand the code for generating the plots and pay close attention to the "Aggregating using Split-Apply-Combine" part. We will need this in the lecture.
• "Data Cleaning - Dealing with Outliers": Understand the code they use for grouping and cleaning data.
• "Basic Statistics in Python: t tests with SciPy": Read this section up to "One-sample t tests".

During the class: We will apply what you learn from the readings to another familiar dataset.

03.07. | Techniques for preventing and fixing bgus

To prepare before: Before the lecture, think about the following questions:

• What do you expect of code that is used for scientific papers, and that is used in research labs to analyse data?
• How much time do you spend writing code, and how much time do you spend reading and trying to understand code?
• What strategies do you currently use when your code does not behave as expected?

During the class: We will talk about these questions in class and will go through techniques like assertions, automatic tests, and human and LLM-based code review.

10.07. | Finishing last lecture and exam project help-desk

To prepare before: Think about what you would like to talk about during the help desk. Do you face any bugs?

During the class: We will talk about the expectations for the exam projects and you will be able to get help from us.

Exam programming project guidelines

General points

• You can work together in teams of max. 4 students per exam project.

• The exam project will be not graded (pass/fail).

• Projects may be selected from the list provided on bwJupyter or one of your own ideas. Projects based on your own ideas are very welcome!

• During the last two sessions of the class, every group will present their project (10 min + 5 min for questions). The presenter will be selected at the session, therefore everyone in the group has to be prepared.

• As discussed during the course, AI can be used for support, however, you have to declare how you have used it in the documentation of the project.

• If we realize the the project was simply copy & pasted from an existing solution from the internet, the team will fail.

• Right after the presentation, teams have to submit their program to ILIAS, either as a .zip file containing the complete code and documentation or as a .txt file containing the link to a GitHub repository.

Evaluation criteria

Your project will be evaluated according to the following criteria:

• Complexity and scope of project: How difficult is the task and how much programming is needed - 20%
• Functionality: Does the program accomplishes job described in project description - 30%
• Readability of code: How well can the code be understood by someone who did not participate in the development (see also below) - 30%
• Efficiency: How does the program perform in terms of speed, usage of memory, vectorized code, preallocation, etc. - 5%
• Versatility: How flexible is the program (e.g., input & output arguments, error-checking and -handling) - 5% _ Presentation: How well is your exam project presented - 10%

Documentation

Essential parts of a good documentation include:

• A readme file/document that gives the user a clear starting point
• A description how to use the program (e.g., what is needed, how is it run, are there specific requirements etc.)
• Comments in the code (ideally, approx. 50% of the text should be comments)

Improving Readability of the code

• Compartmentalization: Divide the code into sections/modules/parts that have a defined (sub) function
• Use meaningful variable names
• Add function descriptions that indicate what a function requires as input and what output can be expected

Other points to consider

• If you choose to write a 'traditional' program, the 'core' code must reside within a central function, plus other functions, if needed. This function may be called by a script for the presentation (see below). Please give your central function a telling name, not something like 'main.py'.
• Also, if you choose a Jupyter notebook as basis for your project, your program needs to be well-organized into functions.
• The (central) function shall take input arguments and possibly produce output arguments to make the code versatile. For example, the spike threshold detector would certainly need a data array (or a data file name) and a threshold as inputs and return timestamp lists.
• Sanity checks of input variables must be performed and some precautionary measures against nonsense input should be taken. Try to catch common errors.
• The purpose of the function(s) and the nature of the input and output variables must be well explained in your code ( e.g. the size of variables, data type, what kind of data etc.).
• Extensive documentation of the code should be provided. Place comments on top of the code lines they are supposed to comment, not in the same line as the code itself, and keep your comment in the visible part of the screen by starting new lines.
• Check out again the recommendations for good (Python) coding practice as discussed in Lectures 1 and 2. Your final code should be designed to be adaptable to other similar programming tasks and it should be comprehensible by others ( e.g., use).
• Make sure the data which your program will digest or generate during the presentation is of a manageable size so that your demo computations finish in finite time.
• For some of the projects there is already Python code around on the internet. It goes without saying that the task is NOT to do a simple copy-and-paste job. Detecting large chunks of verbatim copies of publicly available code or of code from the previous terms students will result in failing the course.
• Make sure that you observe any copyrights when using material (e.g., data, images, resources) of others.