# Python For Kids: a MicroPython course built around the BBC micro:bit > Python For Kids is a free, chapter by chapter tutorial that teaches children to program a BBC micro:bit in MicroPython, from a first hello world through images, numbers, lists, functions, classes and unit tests. The code sits in Part_* directories, the lessons are delivered as a single PDF, and every chapter link in the README points at that same file. **mytechnotalent/Python-For-Kids** — A FREE comprehensive online Python development tutorial FOR KIDS utilizing an official BBC micro:bit Development Board going step-by-step into the world of Python for microcontrollers. - Repository: https://github.com/mytechnotalent/Python-For-Kids - Stars: 801 · Forks: 118 - Language: Python - License: Apache-2.0 - Published: 2026-10-20 · Updated: 2026-10-20 · Language: en - Canonical page: https://hysenlabs.com/projects/mytechnotalent-python-for-kids ## What the course is actually for The project description is unusually explicit: a free comprehensive online Python development tutorial for kids utilizing an official BBC micro:bit development board, going step by step into the world of Python for microcontrollers. That last clause is the important one. The course is not general Python on a laptop. Every lesson is anchored to a physical board a child can hold, and the software being taught is MicroPython, the Python dialect that runs on the micro:bit. The repository topics list micropython, microbit, mu, stem and educators, which tells you the intended setting is a classroom with hardware, an editor and a teacher. The course structure is fifteen chapters, and the chapter descriptions read like a syllabus. Chapter 1 sets the goals, addressing why kids should learn to program in Python. Chapter 2 is hello world. Chapters 3 through 8 are the ones the author labels FUN: making images, working with numbers, working with words, working with word lists, making music, and interacting with a talking robot. Chapters 9 to 15 are the more conventional curriculum: basic input and output, data types and numbers, conditional logic with application flow chart design, lists, tuples, dictionaries and loops, functions, classes and unittest. The ordering is deliberate and worth noting for anyone adapting it. The playful lessons come first, while the syntax lessons follow once the child already has something motivating to build. A child who has made the board play a song before meeting a tuple is a different classroom experience from one who starts with data types. There is also a companion resource linked at the top of the README, a free reverse engineering self-study course hosted as a separate repository under the same account, so the author is building a sequence rather than a single artefact. ## How the lessons and the code are separated The repository splits into three kinds of content, and the split explains most of what you will and will not find here. First, the lessons themselves. There is one PDF at the top level, Python_For_Kids_01r.pdf, and every chapter in the README links to it with the same instruction, to click HERE to read the lesson in PDF format. That is a factual detail with a practical consequence: the README is a table of contents for one document rather than a set of separate documents, so the per-chapter links do not take you to a chapter-specific file. Second, the code. The top level listing shows a series of Part_* directories that mirror the chapter topics. Part_1_Basic_IO, Part_2_DataTypes_+_Numbers, Part_3_Conditional_Logic, Part_4_Lists_Tuples_Dictionaries_Loops, Part_5_Functions, Part_6_Classes and Part_7_Unittest form one progression, and alongside them sit directories named after the FUN chapters, Part_2_V2_Hello_World, Part_3_V2_FUN_With_Images, Part_4_V2_FUN_With_Numbers, Part_5_V2_FUN_With_Words, Part_6_V2_FUN_With_Word_Lists, Part_7_V2_FUN_With_Music and Part_8_V2_FUN_With_Talking_Robots. Third, the media: an image file for the course banner and a link to a promotional video on YouTube. So a teacher picks a lesson from the PDF and then finds the matching code in one of these folders. The mapping is not obvious from the names alone, and a chapter plan built purely from the README links will not tell a student which folder to open. ## Two numbering schemes that do not line up The directory names carry two different numbering systems, and they conflict with the chapter numbers in the README in a way that costs time if you do not spot it. The Part_N directories follow a sequential order. Part_1 is Basic IO, Part_2 is DataTypes and Numbers, Part_3 is Conditional Logic, Part_4 is Lists, Tuples, Dictionaries and Loops, Part_5 is Functions, Part_6 is Classes and Part_7 is Unittest. That sequence matches the order of the later README chapters, which run from Chapter 9 on basic I/O through Chapter 15 on unittest. The Part_N_V2 directories carry the same numeric prefix but a different topic. Part_2_V2_Hello_World is chapter 2 in the README, Part_3_V2_FUN_With_Images is chapter 3, and so on through Part_8_V2_FUN_With_Talking_Robots as chapter 8. Their Part numbers align with the README chapter numbers, but their topics belong to the early playful lessons rather than to the Part_N sequence they sit next to. The result is that Part_2 and Part_2_V2 are unrelated to each other, and neither Part_1 nor Part_8 alone tells you which README chapter it serves. A student who opens Part_4 expecting chapter 4 finds lists, tuples, dictionaries and loops, while chapter 4 in the README is the FUN With Numbers lesson, whose code is in Part_4_V2_FUN_With_Numbers. None of this is fatal, and the V2 suffix suggests the author rebuilt the playful lessons as a second pass. But for anyone who wants to reuse the course, the README does not map lessons to folders, and a classroom handout that sends children to the wrong directory wastes a lesson period. ## The teaching approach, text first rather than blocks first The approach taken here is text-first. By chapter 2 the child is writing a program that makes the board say hello to the world, and by chapter 9 the curriculum has reached basic input and output with MicroPython syntax. That is the meaningful difference in approach against the more common alternative for this hardware, where a child assembles a program from draggable visual pieces and the text code is generated for them. This course starts from the typed program and keeps the physical device as the feedback loop, so errors are read as text and the board's screen and buttons are the output. The reasoning behind that choice shows up in the chapter descriptions. Chapter 11 pairs conditional logic with application flow chart design, so the child writes code and reasons about control flow on paper at the same time. Chapter 12 puts lists, tuples, dictionaries and loops together in one lesson, which is a dense session for a beginner and works better once the earlier FUN chapters have made the board interesting. Chapter 15 is worth flagging for a teacher. Unittest on the micro:bit means the child writes tests for hardware-driven code, which is unusual for this audience and unusual for the board. It is a strong note to end on for a technical track, and it also shows the course does not stop at the point where the projects stop being fun. The chapters on music and the talking robot are the ones that make the hardware pay off, and for a classroom they are the sessions most likely to be remembered. ## What to verify before you teach from it There is no installation guide, and that is not a gap so much as a statement about the shape of the course. The repository is documentation and sample code, not a package to install. There is nothing to pip install and no requirements file in the top level listing. What you need instead is the hardware and the toolchain the author assumes. The board is an official BBC micro:bit development board, the language is MicroPython, and the repository topics include mu, which points at the Mu editor as the environment used to write and flash the samples. A teacher who has never flashed a board will spend the first session on that instead of on the lesson, and the README does not cover it. The checks worth doing before a class starts are these. Read the PDF end to end, since it is the entire course in one file and the README summaries will not tell you how the lessons actually proceed. Open each Part_* folder and confirm the code runs on your board and editor version, rather than assuming the naming tells you the mapping. And decide how a child with no board still participates, because the whole design assumes a device in the hand. A second point is about the course files, in the practical sense. The lessons are delivered as a PDF hosted in the repository, which makes them easy to print for a classroom and easy to lose if the file changes. Download it and keep your own copy alongside the code, so that your handouts and the repository stay consistent. The reverse engineering course linked at the top of the README is a separate repository with its own structure, so treat it as a separate decision rather than a chapter range of this one. ## Licence, maintenance and what this repository is not The project is licensed under the Apache License, Version 2.0, with a LICENSE file at the top level and a badge linking to the licence text. Apache 2.0 is permissive, allows modification and redistribution with notice retention, and includes an explicit patent grant, which makes it a workable choice for a course a school or company might adapt into its own curriculum. This is not legal advice, and the attribution terms still apply to any copy you distribute. The repository is not archived and the last push was on 2026-10-10. There are no GitHub releases, which suits a course that evolves by adding and revising lessons rather than shipping versions. It is worth being clear about what this project is not. It is not a Python tutorial in general: the language coverage is MicroPython on one specific board, and the concepts are introduced in the order that suits a classroom with that board. It is not a library, so there is no API to adopt and no upgrade path beyond the sample code changing. And it is not a substitute for the official MicroPython documentation, which a serious class will need the moment a student asks a question the PDF does not answer. What it is worth is a ready-made path. Fifteen chapters, a progression from a first program to unit tests, and sample code for each part, laid out for people who want to teach or self-study Python on inexpensive hardware, and available at no cost. ## Conclusion Use this course if you are teaching a class of children who have a BBC micro:bit and want a structured, printable path from hello world to unit tests without writing your own syllabus. Do not use it as your only source, since the lessons live in one PDF, every chapter link resolves to that same file, and the code directories carry two competing numbering schemes that do not line up with the chapter numbers. Before you plan a term around it, open Python_For_Kids_01r.pdf and read the chapters yourself, check that your micro:bit and editor setup matches the one the samples assume, and confirm which Part_* directory holds the code for each lesson before handing it to a class. ## FAQ ### What does the Python For Kids course teach? It teaches children to program a BBC micro:bit in MicroPython across fifteen chapters, starting with why kids should learn to program and a hello world, moving through playful lessons on images, numbers, words, word lists, music and a talking robot, and ending with basic I/O, data types, conditional logic, lists and loops, functions, classes and unittest. ### Where are the lessons and the sample code in the Python-For-Kids repository? The lessons are all in one PDF, Python_For_Kids_01r.pdf, and every chapter link in the README points at that same file. The sample code is in the Part_* directories at the top level, which cover basic I/O, data types and numbers, conditional logic, lists, tuples, dictionaries and loops, functions, classes and unittest, plus V2 folders named after the FUN chapters. ### Do I need to install anything to use the Python For Kids course? The repository contains lessons and sample code rather than an installable package, and the README gives no installation steps. You need an official BBC micro:bit board and a MicroPython environment, with the repository topics pointing at the Mu editor. ### How do the Part_ folders map to the chapter numbers? They do not line up cleanly. The Part_N folders follow the order of the later README chapters, from Part_1_Basic_IO to Part_7_Unittest, while the Part_N_V2 folders carry the chapter numbers of the earlier FUN lessons, so Part_4 holds lists and loops while chapter 4 lives in Part_4_V2_FUN_With_Numbers. ### What licence is Python For Kids released under? It is licensed under the Apache License, Version 2.0, with the LICENSE file in the repository root. The repository is not archived, the last push was on 2026-10-10, and there are no GitHub releases. ## Sources - [Issues](https://github.com/mytechnotalent/Python-For-Kids/issues) - [License: Apache-2.0](https://github.com/mytechnotalent/Python-For-Kids/blob/main/LICENSE) - [mytechnotalent/Python-For-Kids on GitHub](https://github.com/mytechnotalent/Python-For-Kids) - [README](https://github.com/mytechnotalent/Python-For-Kids/blob/main/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/mytechnotalent-python-for-kids