My account Contact me

McGill University • Montreal

COMP 202 Tutor in Montreal, McGill Foundations of Programming

Struggling with COMP 202 at McGill? I offer private tutoring for McGill's introductory Python programming course in Montreal. Whether you're stuck on functions, loops, lists, or your first OOP assignment, I help you understand the concepts, not just copy the solution.

8 chapters, 90 corrected exercises and 8 revision sheets, plus one set that covers the whole term at once. Free, no account needed: the full worked solution is on the page.

  1. 1 Types, conversion and conditions The first third of COMP 202, the part every later assignment stands on. Part A takes the mechanics: what an operator means once the types on either side of it change, the border between the text world and the number world that input and int cross in opposite directions, the binary fractions behind 0.1 + 0.2, De Morgan and the precedence that makes not a == b mean a != b, and a cascade of elif written in increasing order that collapses onto its first branch. Part B works at midterm level: a fare program with one error message and one silent wrong answer, the leap year rule and the price of testing in the wrong order, five statements to correct, a dosage calculator judged on its boundaries, and progressive tax brackets where the classic bug charges nearly twice what is owed. Sheet
  2. 2 Loops and the patterns they carry The chapter where a program stops being a list of instructions. Part A takes the mechanics: the question that decides between for and while before a line is written, the accumulator family beyond the sum with the neutral starting value each one needs, break and continue and the else that belongs to a loop, the order in which a nested loop visits its pairs, and a trace table filled row by row on a program that peels the digits off a number. Part B works at midterm level: a menu loop with three ways of never ending, the Collatz sequence whose length no for loop can bound, five statements to correct, a savings account where the answer is the month itself, and a primality test cut from 9971 divisions down to 98. Sheet
  3. 3 Strings and text processing The chapter every assignment of the term goes through, because data arrives as text. Part A takes the mechanics: negative indices and the step of a slice, the string methods sorted by what they GIVE BACK rather than learned one by one, split and join as the two halves of one idea with the empty field that survives a double separator, the four ways to ask where a substring is and the -1 that is also a valid index, and building a string in a loop against joining once. Part B works at midterm level: one line of a data file taken apart field by field, palindromes with the reverse slice and with two pointers, five statements to correct, a Caesar cipher with its wrap around, and word statistics computed without a single dictionary. Sheet
  4. 4 Functions, scope and program design The chapter that decides the mark on every assignment after it. Part A takes the mechanics: the header read as a contract with its keyword arguments and its defaults, return with one value or several and the None that travels when there is none, scope and the UnboundLocalError raised on a line ABOVE the assignment that caused it, the design choice between giving back something new and changing what you were given, and the docstring with the three tests that go with it. Part B works at midterm level: one long script cut into six functions with its call graph, a small library of date functions built on each other, five statements to correct, a dice simulation judged against the exact distribution, and a function handed to another function. Sheet
  5. 5 Lists, dictionaries and the structure to choose The chapter where a program stops holding one value at a time. Part A takes the mechanics: the list methods sorted by what they give back, with every mutating call returning None; the copy that stops at the first level and the inner lists it leaves shared; the dictionary and the lookup whose cost does not grow; the counting idiom with get that replaces a quadratic scan by a single pass; and sets and tuples, each defined by what it refuses. Part B works at midterm level: a board read by row then column with its diagonals, an inventory whose values are records, five statements to correct, two class lists merged with set operations and a dictionary of lists, and five situations where the structure is chosen before the loop is written. Sheet
  6. 6 Files, exceptions and real data The chapter where the program meets the outside world. Part A takes the mechanics: the modes of open and the one that empties the file the moment it is opened, a file read as one run of characters where a line still carries its newline and a handle read twice gives nothing the second time, writing that adds nothing at all to what it is given, the four clauses of try with the bare except that stops the user from interrupting, and the table of exceptions read as the contract each one names. Part B works at midterm level: an input function that survives its user, a CSV of temperatures turned into a report, five statements to correct, a file written and read back, and the design question of WHERE an exception should be caught. Sheet
  7. 7 Recursion, and when a loop is the better answer The chapter students either understand in one afternoon or fight for a term. Part A takes the mechanics: the two obligations of a recursive function and the four ways of breaking them, reading a recursion by trusting the call rather than unrolling it, the stack of frames and the thousand deep limit that turns a runaway recursion into an exception, recursion on a string with the slicing that quietly copies, and recursion on a number where halving and subtracting give completely different depths. Part B works at midterm level: binary search written with indices and its off by one, the towers of Hanoi and the difference between exponential work and repeated work, five statements to correct, a structure of unknown depth that no loop can walk, and memoisation cutting two and a half million calls down to fifty nine. Sheet
  8. 8 Classes and objects The last chapter of COMP 202, and the one that decides the final assignment. Part A takes the mechanics: the class as a blueprint and self as the object to the left of the dot, the attribute written in the class body that every object shares against the one written with self, the methods Python calls for you when you print or compare, the invariant a class exists to guarantee, and an object handed to a function where mutating is visible and rebinding is not. Part B works at the level of a final assignment: an account that keeps its promise, a list of objects compared with the dictionary of records it replaces, five statements to correct, a course made of students, and inheritance with the one test that says when not to use it. Sheet

Before a midterm

Python foundations, COMP 202 at McGill

The ten exercises a COMP 202 student actually loses marks on. Part A is the mechanics: the three division operators and the negative floor, truth values and short circuiting, the boundaries of range and the accumulator pattern, string slicing against string indexing, and list aliasing drawn as a memory diagram. Part B works at midterm level: call frames and the print against return distinction, nested loops and the list-of-lists trap, five plausible statements to correct, a file of marks read and reported on, and a naive Fibonacci whose call tree explains why correct is not the same thing as usable.

10 exercises across the whole course →

What is COMP 202?

COMP 202, Foundations of Programming, is McGill University's introductory computer science course. It is the general introduction to programming, open to students from any program: life sciences students usually take COMP 204 and engineering and physical sciences students COMP 208 instead. For many students it is also the first step before COMP 250. The course is taught in Python.

Despite being an "intro" course, COMP 202 has a reputation for being challenging for students with no prior programming experience. The concepts build on each other quickly, and the assignments require genuine problem-solving, not just memorizing syntax.

The main difficulty is the shift in thinking required. Programming demands a precision and logical structure that most students haven't needed before. A tutor who can bridge that gap, explaining not just what to write but why, makes a significant difference.

COMP 202 topics I cover

Python basics

  • Variables, types, expressions
  • Conditionals: if / elif / else
  • Loops: for, while, range
  • Input / output, string formatting
  • Debugging common errors

Corrected exercises: types and conditions • loops

Functions and scope

  • Defining and calling functions
  • Parameters, return values
  • Local vs. global scope
  • Recursion and base cases
  • Helper functions and decomposition

Corrected exercises: functions and scope • recursion

Data structures

  • Lists: indexing, slicing, methods
  • Tuples and immutability
  • Dictionaries: keys, values, iteration
  • Strings as sequences
  • Nested structures

Corrected exercises: lists and dictionaries • strings

Files and OOP

  • Reading and writing files
  • Parsing CSV and text data
  • Classes and objects
  • Attributes and methods
  • Basic inheritance

Corrected exercises: files and exceptions • classes and objects

Common COMP 202 mistakes and how to fix them

Confusing assignment with equality

Using = when you mean == is one of the most common bugs for beginners. Understanding the difference between storing a value and comparing two values prevents hours of frustration.

Not returning a value from a function

Writing a function that prints a result instead of returning it, then trying to use the result elsewhere. Understanding the difference between print() and return is fundamental.

Mutating a list while iterating over it

Modifying a list inside a for loop that's iterating over it produces unexpected results. Knowing when to iterate over a copy, or when to build a new list, is a key skill for COMP 202 assignments.

Off-by-one errors in loops

Loops that run one iteration too many or too few. Understanding how range() works, and why it stops before the end value, clears up a huge number of bugs.

Other McGill and Concordia CS courses

Beyond COMP 202, I also tutor the following courses:

COMP 204, Python for Life Sciences

Similar to COMP 202 but with a biology and data focus. Functions, loops, NumPy basics, file processing.

COMP 206, Intro to Software Systems

C programming, Unix command line, memory management, pointers, Makefiles, shell scripting.

COMP 250, Intro to Computer Science

Java, data structures (linked lists, stacks, queues, trees, graphs), sorting algorithms, complexity analysis.

Concordia COMP 248 / 249

Object-oriented programming I and II in Java. Classes, inheritance, polymorphism, interfaces, exception handling.

Why work with me for COMP 202

I hold a B.Sc. in Computer Science, Finance and Mathematics from McGill University and an M.Sc. in Applied Computer Science from Concordia University. I've been tutoring programming in Montreal for over 10 years, from introductory Python to advanced data structures and algorithms.

I know exactly where students get stuck in COMP 202, and more importantly I know how to explain the concepts in a way that builds real understanding. My goal isn't to get you through one assignment. It's to make you a stronger programmer.

✓ B.Sc. Computer Science, Finance and Mathematics at McGill University
✓ M.Sc. Applied Computer Science at Concordia University
✓ 10+ years tutoring computer science in Montreal

Other first-year courses

The same free corrected material exists for other courses, some of it in English and the rest in French.

PHYS 101, Introductory Mechanics (McGill)MATH 133, Linear Algebra and Geometry (McGill)MATH 140, Calculus 1 (McGill)MATH 141, Calculus 2 (McGill)MATH 203, Calculus I (Concordia) Computer science tutoring in Montreal All revision sheets in English Higher education, in French

Frequently asked questions

What is COMP 202 at McGill?

COMP 202 (Foundations of Programming) is McGill University's introductory programming course. It teaches Python programming fundamentals including variables, control flow, functions, lists, dictionaries, file I/O, and basic object-oriented programming.

Do you offer COMP 202 tutoring in Montreal?

Yes. I offer private tutoring for COMP 202 and other McGill introductory programming courses in Montreal, both in-person and online via Microsoft Teams.

What other McGill CS courses do you tutor?

In addition to COMP 202, I tutor COMP 204 (Python for Life Sciences), COMP 206 (Introduction to Software Systems, in C), COMP 250 (Introduction to Computer Science, in Java), and other introductory CS courses at McGill and Concordia.

★ 5.0 · 11 Google reviews

Need help with COMP 202 in Montreal?

Get in touch to book a first session, in person or online, adapted to your schedule.

Contact me WhatsApp

← Back to English home

Site by Studio Squalli