Learn Python with a free video course: how to use the 88 episodes and 21 OOP lectures

Python is often the first programming language people learn, and for good reason: its syntax is close to plain English, it is used for websites, data analysis, automation, science and teaching, and a small amount of Python does a lot of work. This site has a free Python video course made of 88 episodes and 21 lectures on object-oriented programming. That is a lot of video, and a lot of video is easy to start and hard to finish. This guide explains what the course contains, how long it really takes and a method for working through it so that you come out able to write programs, not just recognise them.

What is in the course

The course has two parts:

• The episodes (88). The first is a setup episode on installing Python and basic details. The remaining 87 run in order from "why Python" through the language's building blocks to files, errors, threads and databases.
• The OOP lectures (21). A separate series on object-oriented programming: classes, objects, inheritance and the ideas around them.

Together the videos run to roughly 129 hours: about 109 hours for the episodes (the shortest is about 36 minutes and the longest about two and a half hours) and about 20 hours for the OOP lectures. These are long, detailed sessions, not three-minute clips. Plan accordingly.

You do not have to watch them all to be useful. A learner who finishes the first 40 episodes can already write real scripts. The rest adds depth.

The course page lists each episode by number, with a title for the ones whose topic is known. A tick marks the ones you have watched, stored on your device, so you can see how far you have come. A written version of the Python course, with the same format as the PHP, MySQL and HTML courses (short lessons, quizzes, an exam and a certificate), is planned but not ready yet. There is no Python exam or certificate today.

Topics you will meet

The early episodes cover why Python is a good first language, its features and syntax, how it works internally, identifiers, keywords and data types, and base conversions. After that the course builds up the standard topics in order. Later episodes cover:

• error handling, including how try, except, else and finally combine,
• logging and pickling objects,
• object-oriented programming in several sessions,
• regular expressions in two parts,
• multithreading, multitasking and synchronisation,
• shallow and deep copy,
• database connectivity and database programming.

The final episode closes the series. Episode numbers matter: the course is meant to be followed in order, since each one assumes the previous ones.

How to study a video course

The main danger of a video course is passive watching. You nod along, everything makes sense, and a week later you cannot write a loop. Programming is learned by doing, so use the videos as a guide for your own typing.

1. Pause and type. When the instructor writes code, pause and write it yourself. Run it. Change a value and predict the result before you run it again.

2. Take notes in your own words. One short paragraph per episode: what was it about, and what would you tell a friend? If you cannot write it, rewatch the part you missed.

3. Do an exercise after each episode. Invent one: "write a program that asks for a number and prints its square" is a fine exercise. Ten minutes of your own code teaches more than an hour of watching.

4. Use a rhythm. Aim at one episode a day, or three a week, rather than a marathon on Sunday. Long videos are best watched in two sittings with a break between.

5. Keep a project folder. Save every program you write, named by episode. By the end it is your own reference.

6. Watch at the right speed. Slow down for new ideas and speed up for review. Do not skip the parts about errors; reading error messages is a core skill.

7. Revisit. After every ten episodes, spend a session rewriting examples from memory without looking.

A staged plan

The course page gives episode numbers and, for some episodes, a known topic; it does not publish a fixed chapter list. So treat this as a way to split your effort by position in the series, and check each episode's opening minutes to see what it covers.

Stage	Where	What to aim for
1	Setup episode and the first ten episodes	Python installed, scripts running, and the first ideas (why Python, how it works, data types) understood well enough to explain
2	Episodes 11 to 40	Writing small programs of your own after every few episodes: input, decisions, repetition, collections of data
3	Episodes 41 to 60	Structuring code, handling errors (the try, except, else, finally episodes are around 51 and 52), logging and pickling
4	OOP lectures 1 to 21, together with the OOP sessions near episode 61	Designing and using classes, and explaining inheritance in your own words
5	Episodes 64 to 87	Regular expressions, threads, copying, and database programming, ending with the final episode

At about one episode a day, the 88 episodes take three months, and the OOP lectures about three weeks. Combined with exercises, expect four to five months of part-time study.

What you should be able to do as you go

Stop at the end of each stage and test yourself with a small program, not another video:

• Stage 1: a program that reads input, does arithmetic and prints a formatted result.
• Stage 2: a program that processes a list of records, for example finding the highest mark or counting words in a text.
• Stage 3: a program split into functions that survives bad input without crashing.
• Stage 4: a model of a real thing with classes, such as a bank account or a library.
• Stage 5: a script that reads and writes files, searches text with patterns, and stores data in a database.

If you cannot do these things, go back and practise; do not move on just because the video ended.

Pairing it with the other courses

Python is a general-purpose language, and it combines well with the rest of the site:

• Learn SQL with the MySQL course alongside the database episodes, so the queries make sense.
• Learn how the web works with the HTML and CSS courses if you want to build websites with Python later.
• Compare ideas in the PHP course. Having a second language makes both clearer, and the object-oriented lessons there cover many of the same concepts.
• Practise text patterns with the Regex Tester while you watch the regular-expression episodes, and format data with the JSON Formatter.

Practical tips

• Install a recent Python from the official site, and a code editor that highlights Python.
• Use the setup episode for installation, then check with python --version.
• Don't copy and paste code from video descriptions; type it.
• Ask a precise question when you are stuck: what you wanted, what you wrote, what happened.
• Do not collect courses. Finish this one before starting another.

Common mistakes

• Watching several episodes in a row without writing code.
• Skipping the early episodes because they seem easy.
• Memorising instead of understanding.
• Giving up after a hard episode. Threads and regular expressions are hard for everyone; rewatch and experiment.
• Never building a project of your own. After stage 3, write a small tool: a quiz, a budget tracker, a file renamer.

Quick answers

How long are the videos in total? About 129 hours: roughly 109 for the episodes and 20 for the OOP lectures.

Is there a Python certificate? Not yet. The written course with an exam is planned.

Do I have to watch in order? Yes, especially the first half.

Is my progress saved? Watched ticks are kept in your browser on that device.

Do I need to know programming first? No. The course starts with installing Python.