CS-104: Fundamentals of Python

About this course

The bytecode interpreter and dynamic typing through strings, control flow and core data structures to functions, classes and safe file I/O, with a real-life analogy, a video, and a scenario-based Compiler Quest for every one of 15 topics across 5 modules.

This is a 6-week short course - enough depth to build real projects and a portfolio piece, without a long commitment. Learn online at your own pace. Practice the concepts with the listed assessments.

What's included

• Self-paced lessons and practice (12 estimated hours).
• Hands-on coding quests you solve inside the EchoLens browser compiler - nothing to install.
• Gems, stages and a leaderboard that keep you moving instead of grade anxiety.
• A verified certificate with a scannable QR code, ready to share on LinkedIn, when you satisfy the course requirements.
• Completely free - no fee, just create an account and start.

What you will learn

Course outline - level by level

15 leveles, each with hands-on quests you clear in the portal.

• Level 1. Python Interpreter & print() - Real-life analogy: Think of a live simultaneous translator reading a speech line-by-line, speaking each sentence as it arrives - never waiting for the whole book to be printed and bound first. Python runs on a bytecode interpreter that executes your source one statement at a time, so there is no separate compile-and-link step to wait through. The print() function sends formatted text to standard output; its sep parameter sets what goes between multiple arguments (a space by default) and its end parameter sets what finishes the line (a newline by default).
• Level 2. Dynamic Variables & Types - Real-life analogy: Think of a universal storage bin. You peel off the old label sticker and put on a new one whenever you want - today it holds shoes, tomorrow books, the day after coins - the bin never cares what type of thing goes in. Python variables are names that refer to objects on the heap, and the same name can be rebound to a value of a different type at any time - you never declare a type. The core primitives are int (whole numbers), float (decimals) and bool (True / False), and type(x) reports which one an object is.
• Level 3. User Input with input() & Type Casting - Real-life analogy: Think of a microphone capturing raw audio as text. Before a synthesizer can play it back as musical notes, that text has to be converted into numerical pitch frequencies - the raw capture alone is not a number. input() always returns a str, no matter what the user types. Before any arithmetic you must cast it with int() or float(); skipping the cast either raises a TypeError or silently does string work ("20" * 3) instead of maths.
• Level 4. String Slicing & f-Strings - Real-life analogy: Think of cutting one specific rectangular frame out of a long film strip (slicing), then laying a dynamic subtitle over that frame (an f-string). Strings are immutable sequences. The slice str[start:stop:step] returns a new substring without changing the original, and an f-string f"{value}" drops variables straight into text - faster and clearer than + concatenation.
• Level 5. Decision Structures (if, elif, else) - Real-life analogy: Think of an automated postal sorting machine dropping each letter into the local, domestic or international chute based on its postcode - one letter, exactly one chute. if tests a condition; elif checks the next one only when every earlier test failed; else catches everything left over. Conditions use comparison operators (< > == !=) and can be combined with the logical operators and, or and not.
• Level 6. Iteration with for & while Loops - Real-life analogy: Think of a quality-control conveyor belt that examines every box in turn, and keeps going until someone hits the emergency stop button. A for loop steps over a range or a collection a known number of times; a while loop repeats as long as its condition stays true. break leaves the loop early and continue skips straight to the next iteration.
• Level 7. Lists & List Comprehensions - Real-life analogy: Think of a digital shopping cart you can add to, remove from, reorder, or run a bulk discount across in a single pass. A list is a mutable, ordered sequence. A comprehension [expr for x in iterable if cond] builds a whole new list in one readable line, replacing the append-inside-a-loop pattern.
• Level 8. Tuples & Sets - Real-life analogy: Think of a sealed birth certificate that can never be edited (a tuple), and an automated party guestbook that silently refuses to write down a name it already has (a set). A tuple (x, y) is an immutable record - fixed the moment it is created. A set {a, b} stores only unique values and offers O(1) membership tests plus set algebra (union, intersection, difference).
• Level 9. Dictionaries & Key-Value Lookups - Real-life analogy: Think of a physical telephone directory - you look up a contact name and get their number instantly, without scanning every page one by one. A dictionary {key: value} stores pairs and finds a value by key in near-constant time. .get() reads safely with a fallback, and .keys(), .values() and .items() let you iterate the parts.
• Level 10. Defining Functions & Default Arguments - Real-life analogy: Think of a coffee vending machine with recipe buttons. Press Espresso and it uses the standard recipe; or optionally dial in a custom sugar level before you press. def names a reusable block that takes parameters and hands back a result with return. A default argument (people=2) makes a parameter optional, and defaults must come after all the required parameters in the signature.
• Level 11. *args, **kwargs & Variable Arguments - Real-life analogy: Think of an open grocery bag that stretches to hold any number of items (*args), plus a box of labelled gift tags where each tag has a name and a value (**kwargs). *args collects any extra positional arguments into a tuple; **kwargs collects any extra named arguments into a dict. Together they let one function accept a variable number of inputs.
• Level 12. Lambda Expressions & Scope (LEGB) - Real-life analogy: Think of a disposable sticky-note calculation you use once and throw away - and you always check your own desk notes before walking over to the office noticeboard. A lambda is a small anonymous function written inline: lambda x: x * 2. Name lookup follows LEGB - Local, then Enclosing, then Global, then Built-in - so an inner scope can see outer names but not the other way round.
• Level 13. Classes, Objects & __init__ - Real-life analogy: Think of an architect's blueprint that defines what every car has, versus each physical car rolling off the production line built from that one blueprint. A class bundles data (attributes) and behaviour (methods). __init__(self, ...) runs automatically when an object is created and sets up its starting state; self is the current object, passed first to every method.
• Level 14. Inheritance & Polymorphism - Real-life analogy: Think of a smart tablet that inherits every standard smartphone feature, then adds stylus support and a larger screen on top. class Child(Parent) reuses the parent's code. super().__init__() runs the parent constructor so the child does not repeat that setup, and a child can override a method to change its behaviour while callers keep using the same name.
• Level 15. File Handling with 'with' & Exceptions - Real-life analogy: Think of an automated vault door that unlocks as you step in and swings shut and locks itself the moment you leave - you never have to remember to close it. with open(path) as f: guarantees the file is closed even if an error strikes mid-block. try / except / finally catches failures (a missing file, a bad value) so the program recovers instead of crashing.

How you submit: Coding quests solved in the built-in EchoLens compiler.

Who it's for

CS-104: Fundamentals of Python suits learners at a beginner to intermediate level who want a practical, project-based route into CS-104. You need only a browser and an internet connection - all coding runs inside the EchoLens compiler, so there is nothing to set up.

Certificate

Pass every required assessment at its stated threshold to earn your verified certificate. Optional practice and watching videos do not determine eligibility. Anyone can scan its QR code to verify it on our site. You can add it to your CV or share it to LinkedIn in one click.