loader image

Course syllabus

Python @ CodeDash.net

Nothing of great significance is taught here, but this could be helpful. This is an introductory rant — I mean, lesson — that basically just kicks off the course and introduces you to Python, as well as to me, your friendly course writer and fellow Python learner. If you’re not sure if you want to go through with this Python course, it’s still strongly recommended you go through this lesson first. It’ll show you what the lessons will be like, it’ll give you a little scope on what Python can do and why you’d want it, and it might help you decide a little bit. Beware, though, if you’re not a fan of the unnecessary, you don’t really like reading even if it’s only a little bit, and you want to immediately get into the content, consider skipping this. Go to this lesson > 

Everyone loves a little history, am I right? No? Okay, fine, I’ll admit history wasn’t my favourite subject. Still, it might be good to know a little bit about the history of Python, right? This lesson is mostly a rant, but the different versions of Python are also covered here. Check it out if you just want to learn some more stuff about Python and its versions. Skip it if you really have to and don’t want to get into the theory side so much. Go to this lesson >

Here, we’ll cover how to install the version of Python you want on your PC, then how to set it up and use it. We’ll also set up an IDE and I can give you a couple of recommendations for those as well. This lesson is completely necessary for those new to Python and those who don’t have a development workspace for Python set up yet. Go to this lesson >

This lesson is an introduction into interacting with the user of your program through the default Python terminal window. You’ll learn how to take input data from the user, as well as how to output some data of your own. Go to this lesson >

This chapter is an introduction to the basics of data management in Python. In each of the three lessons, a different core data management concept will be introduced. Though you may be familiar with these concepts if you’re coming from a different programming language, this chapter is fundamental and essential to anyone new to programming. Go to this chapter > 

The main concepts and basic practical uses for variables in Python, an essential part of programming in Python and the core of data storage in many other languages as well, some of which you might already be familiar with from experience with other languages, will be taught in the first lesson of this chapter, PYB1a: What are variables?

An explanation of and the ideas behind lists and arrays, as well as their data management applications in comparison to standard variables, will be discussed in the second lesson, PYB1b: What are lists & arrays?

The three main different types of data used in Python and the usage of different data types will be discussed in the third and final lesson in this chapter, PYB1c: Different types of data. This lesson is very important in understanding and, therefore, avoiding a large majority of common beginner errors. 

In this chapter, we’ll explore the basics of working with data in Python namely using what I like to call conditional clauses, also known more commonly as if/else statements, and a few basic Python operators. The former is explained in the first lesson, PYB2a: What are conditional clauses?, and the latter in PYB2b: What are operators?, the second half and last lesson in this chapter. This chapter is an introduction to working with data and an introduction to understanding essential computational logic in Python. It’s highly recommended to be taken before moving on to the projects or any PYC: Intermediate Python lesson, as this builds the foundation for all logic in your Python code. Go to this chapter >

If you’ve made it here, I won’t lie — you’ve come pretty far! You’re just about done with all of the beginner basics, or, at least, what I’ve outlined as the beginner basics. You may not have ascended to the heavenly and divine power yet, but you’ve laid the foundation for your Python knowledge and taken that first step at the start of your own Python journey. In this chapter, I just wanted to step back and acknowledge — no, not just acknowledge, celebrate — the steps you’ve made on your Python journey and the nearly unlimited potential your later life could hold. Please, take this as a gift from me. I hope this chapter is as informative as it is insightful. Go to this chapter >

Now, as with all journeys and all humans, all journeys are filled with all sorts of obstacles (which is all the more reason why you should be applauding yourself more for making it past my disgusting Python course landing page and all the waffle-full pages to follow and all this rambling from yours truly the insane Python course writer) and all humans are flawed, some more than others (I’m probably on the particularly nasty side of that spectrum). The first lesson in this chapter, PYB3a: What’s wrong with my program?, will cover some basic common errors you might want to look out for while going through PYB and further. Don’t be discouraged if your program and your brilliant masterminding had a slight miscalculation, though: I really hope the second half of this chapter, PYB3b: A message from your fellow programmers, will give you the inspiration and help you need. 

This chapter, unlike the first three in this unit, is not a completely mandatory or highly recommended chapter, rather it’s just something I added because I was bored and thought it would be nice. Sorry. It’d be great if you could spare some time to listen to my rambling! I’ll try my best to make it worth it (sorry if I’ve broken your trust by now). Here’s another link the the chapter, just in case you missed it. Cheers! Go to this chapter >

P.S. I don’t know why I signed off with “Cheers!”. I usually never do that. I swear I’m not an alcoholic. I’m probably going insane. Anyways, see you around and see you soon! 

P.P.S. That was better. Seriously, “Cheers!”?! What was I thinking?

What is this chapter? Short answer: This is the part where your Python course instructor goes officially insane. 

Okay, fine. If you were looking for a longer answer, I’ll give you one, and an honest one at that. This chapter is in no way mandatory, but I have ground to believe that it may be your most fun one yet. Up to this point, you’ve learned all the theory behind Python and how it works. Now, it’s finally time to apply it and put that theory to the test. And, being in this course for so long and fully experiencing the dumbness of it all, you know for a fact that, if you have a type like me as your online Python course writer, you’re going to have quite the time when said insane course writer gets free rein from their boss to create some beginner projects for their students to try out. From yours truly, this is just a taster into my personal collection of fun Python projects you can do and even improve on with the knowledge you just acquired. It’s time. Let’s put theory to the test. Let’s put Python to the test. Let’s put you to a test. Let’s give you a little bit of real coding experience, and let’s have fun at the same time. Let’s do something fun and do something good, and let’s do it really good. Let’s do a thing. Go to this chapter >

Just saying, if you’re not convinced yet, here’s a handy list of a few of the fun hands-on projects I’ve got prepared for you — be warned, though, that this is an incomplete list and that random, obscure, strange, unappealing, and/or insane bonus projects may appear without notice and at my discretion, if I’m particularly bored that day. 

Go ahead and click any of these to get started. Let's do a thing!
PYB4a: A Python Calculator
- PYB4b: Greater Than or Less Than?
- PYB4c: Choose-Your-Own-Ending Story
- PYB4d: Make A Friend! (Sort Of)
Remember, though this syllabus aims to be guide, it isn't a diet.
If you find an interesting project elsewhere, feel free to explore for yourself!
In fact, even feel free to share! I'd love to see all of your projects...


This lesson is a more technical look at text-based input/output (I/O) in the Python terminal taught in PYB0. Here, you’ll find a list and explanation of commonly used backslash and % symbol shortcuts, an explanation on concatenating strings, a list and explanation of some basic methods, some more on Python strings, and other good-to-know and rather neat things. Not completely necessary, but it saves time some of the time, can get you out of a pinch, and is always good-to-know. Go to this lesson >

In this chapter, we’re going more in-depth and technical about Python variables and data management, building on top of the conceptual foundation explained in PYB1. Now that you’re a little more familiar with variables, in each of the six lessons in this chapter, we’ll go over a different concept, some new, some old, and in more detail than before. Yes, not every single different method or form of managing data must be mastered. Yes, you’re not always going to need all of these options. But, I believe that just having the options there helps, and if you could agree, please allow me to lead you through this chapter. With data management being so crucial to programming, I hope that, by the end of this chapter, you can assemble for yourself a grasp of these concepts that will help you both in Python and across the field. Go to this chapter >

In the first lesson, PYC1a: Advanced variable methods, I’ve prepared for your a couple of methods for Python variables you might find useful. We’re also going to discuss the usefulness of variable reassignment (also known as “changing” the value of a variable). Lucky for you, Python has a built-in life hack for that — click that link to the lesson to find out how to use it! 

The second lesson, PYC1b: An intermediate understanding of lists, aims to further your understanding of lists, one of Python’s most useful methods of storing data. Under this umbrella, there’s also PYC1b0: Adding, changing, & retrieving data, a beginner’s guide to managing the data within lists, PYC1b1: Commonly used list methods, listing and explaining methods and additional functionalities you might find useful when handling lists; and, PYC1b2: Nested list shenanigans, complaining about and explaining the thoroughly enjoyable and not at all painful concept of lists inside lists (inside lists inside lists inside even more lists). Enjoy yourself! (Seriously, though, lists are really useful.)

I’m too lazy to write a description for the third lesson, but the lesson title, PYC1c: What are tuples?, should be explanatory. Don’t let this laziness deter you from the lesson, though — tuples are pretty handy and might even save you some time from time to time. 

In the fourth lesson, PYC1d: An intermediate understanding of arrays, we’re taking a look at Python arrays, the close cousin of Python lists.  In their own respective ways, they’re both useful, but make sure you can spot the difference. 

The fifth lesson in this chapter, PYC1e: What are dictionaries?, introduces yet another form of data storage: dictionaries. As you can probably tell from the name, this method is particularly adept at some things, namely, dictionaries (duh), for example, but might not be as efficient for other purposes, all of which we’ll discuss in this lesson. 

The sixth and final lesson in this chapter, PYC1f: A deeper delve into data types, is an elaboration on PYB1c, featuring an ancient Python data type you’ll have to discover. Here’s a hint: in Python 3, we don’t use it anymore (though some other programming languages are adamant on keeping it)! In this lesson, we’re also going to discuss how to switch data between different data types — known as “casting” data — which could potentially fix a lot of data type issues you might have had earlier. 

In this three-part chapter, we’re going to build on top of the foundational knowledge in PYB2. First and foremost, a more detailed list of operators and their explanations will show up in the first lesson, PYC2a: Another look at operators. Next, in PYC2b: Using operators in conditional logic, we’ll apply the use of operators in some practical examples involving Python logic. Last, but not at all least, we’ll take a look at something you’ve probably been dying to do ever since you got your hands on Python — loops! (If the dying part doesn’t make as much sense, it’s probably just me. Sorry.) Hopefully, by the end of PYC2c: What are loops?, you’ll be familiar with the two main types of loops in Python and how to use each of them effectively. Personally, I love the way Python logic starts off so clear and simple but can evolve to something complex and powerful. The simplicity yet complexity of it all really is one of my favourite parts of being a Python user, and I hope this chapter of your Python journey will be as enlightening for you as it was for me. Go to this chapter >

In the world of programming, nothing is more beautiful to a coder than clean code, and that’s what this chapter is all about. You already have all you need to write your program — the basics, the foundation, the logic, the behind-the-scenes — whatever you want to call it. Now, in PYC3a: What are functions?, we’re taking the next step into using functions to not only introduce even more additional functionality and possibilities with your code, but also to make it easy to read both for you and anyone else. (We’re also going to look at lambda, the sister/cousin/daughter/whatever-relative-name-you-want-to-give-it of functions, in PYC3a0: …lambda?!, just in case you wanted it.) As a natural extension to functions, classes are equally as useful and necessary, and we’ll get to unboxing those in PYC3b: What are classes?. While we’re on the topic of more possibilities, in PYC3c: What are modules? we’re also going to take a look at modules, a library and world of Python possibilities at your fingertips. 

Yes, the trek through the Python basics may have been difficult, and I’m not going to pretend there’ll be no more obstacles on your journey. However, I do hope that, with these lessons in which I may or may not have included an unnecessarily long rant on awesome clean coding architecture, I can help you realize the infinite possibilities of Python and lead you into extending your knowledge into something further. Go to this chapter >

Yes, we did have one of these in PYB, but with new possibilities comes new dangers and we must be prepared — so here we go again. But anyways, congratulations for making it this far! Can you believe it? You’re already a pretty formidable Python programmer! In this chapter, I hope to give you some advice and my own insight on tackling those petty obstacles on your Python journey, but this time, we’re not only just discussing and complaining about troubleshooting (even though we are, in PYC4a: The joys of troubleshooting). This time, I think it’s about time we learn some applicable, in-program troubleshooting, and what better to use than the tried-and-true programmer favourite, PYC4b: Trial, error, & exception? We’re also going to explore “with”, the trial-and-error method’s sister/cousin/whatever-close-relative, in PYC4b0: …with?!. Finally, as usual, I’ve also created a list of common errors you might encounter and I definitely encountered while going about using your new Python knowledge, which you can find in PYC4c: Common errors. Remember, all of us at tech1z8.org are here to support you, and we give you this chapter to wish you luck in all your inevitable future crashes (and successes!). Go to this chapter >

Hello there, my students, and welcome to the second round of your Python instructor almost getting fired!

You may have explored the PYB4 chapter a little while ago, and that might explain the extreme cringe you feel towards this chapter. Yes, this is another chapter of your dumb instructor’s dumb games that your mentally unstable instructor has somehow gone completely out of their way to aggregate for you. Sorry. But in all seriousness, I’m super proud that you’ve made it here and I think it’s about time we put that Python knowledge to good use. I know I’ve said this before, but I’m going to say this again: This chapter is in no way mandatory, but I have ground to believe that it may be your most fun one yet. Up to this point, you’ve learned all the theory behind Python, as well as tried and used it in a few situations. Now, it’s finally time to apply it and put that theory to the test in a (hopefully) fun and meaningful way. And, being in this course for even longer than before and fully experiencing the lack of plausibility of it all, you know for a fact that, if you have a type like me as your online Python course writer, you’re going to have quite the time when said insane course writer gets even more free rein from their boss to create even more projects for their students to try out. From yours truly, welcome to my personal collection of fun Python projects. Some of these are just things I decided would be fun to create in Python, others are projects that I’m pretty proud of, even though they may have just stemmed from a random idea. All of these projects are something I had fun with, and I hope you will, too. Oh, wait — did I forget that part? The best part is: you can do all of this too! The truth is, while these projects may look impressive or just downright dense (depending on which side of the spectrum you’re on), anything is possible and you can do them all if you try. Above all, I want to show you my journey to discovering that with just a little Python, a little effort, and a lot of passion, you can create things that go beyond your dreams. Go to this chapter 😀 >

Anyways, here’s a handy list of a few of the fun hands-on projects I’ve got prepared for you. However, as I’ve said before, be warned — this list is an incomplete list. Weird, random, obscure, strange, unappealing, and/or insane bonus projects may appear on here without notice and at my discretion. It really depends how bored I am 😛

Go ahead and click any of these to get started!
- PYC5a: Secret Number Guessing Game
- PYC5b: Assorted Mad Libs
- PYC5c: The Ultimate Customizer! - PYC5d: Supermarket Simulator - PYC5e: The Magic Ball - PYC5f: Lottery Ticket Simulator - PYC5g: Power of 7 Generator - PYC5h: Prime Number Generator - PYC5i: The Art of Rickroll
Hope y'all enjoy! Don't worry, there's more to come soon >:D

Woohoo! We’ve pretty much reached the end of Python basics! I know I keep saying this a lot, but you’ve really learned a lot, and hopefully you’ve even put some of those skills to the test in all sorts of projects! You’ve learned the concepts, you’ve written the code, you’ve done the work, and your program is complete. What now? Well, honestly, I think what we’re about to do is the best part of being a programmer. In this lesson (which I considered putting into some other chapter but decided was too important of a topic to not have its own chapter but anyways), I’m going to take you through compiling and distributing your program to the world. Once we’re through, you can run it on any Windows (PYC6a: Compiling to a Windows executable). Or any Mac (PYC6b: Compiling to a MacOS application). Or even any Linux (PYC6c: Compiling to a Linux software). Granted, you’ll have to compile different files for each system, but that’s what everybody does and it’s good enough. Yes, it’s finally here, and yes, it’s gratification time. It’s the final lesson of tech1z8.org’s Python basics, and it’s time for you to share your code, your passion, and a little part of yourself with the people in the world. Go to this chapter >

P.S. Always remember that those who mind don’t matter, and those who matter don’t mind. It’s been great talking to you, and I hope we’ll meet again~