Intermediate Programming: free practice, theory and problems

1. Object orientation

What is it about?

Object-oriented programming (OOP) lets you bundle data together with the functions that belong to it, in one unit: an object. A class is the blueprint, and an object is a concrete instance of it. As an engineer you use this to model real things – a sensor, a component, a simulation – so the code mirrors the problem and is easier to build on.

Concepts and formulas

• Class vs object: the class class Car: is the blueprint, c = Car() creates an object (an instance).
• Instance attribute: set with self.x = ... in __init__, unique to each object.
• Class variable: set directly in the class body (outside any method), shared by all objects of the class, unless an object gets its own version via self.name = ....
• Magic methods (dunder): __init__ (constructor), __str__ (the text used by print(obj)), __eq__ (==), __len__ (len(obj)).
• @staticmethod: a method without self, logically belongs to the class but does not need an object.
• @classmethod: takes cls instead of self and operates on the class itself (e.g. an alternative constructor).
• Inheritance and overriding: a subclass can define a method with the same name as the parent class; then the subclass's version runs when the method is called (polymorphism).

How to solve the problems

1. Work out whether an attribute is a class variable (shared) or an instance variable (set with self. in __init__).
2. Follow each object separately: which methods are called on which object, and in what order?
3. With inheritance: check which class's version of the method actually runs (the most specific one defined for that object).
4. With a class variable: remember that a change made through one object can affect all others, unless a new instance variable with the same name is created.

Example

class Account:
    rate = 0.02          # class variable, shared by all accounts
    def __init__(self, balance):
        self.balance = balance  # instance variable

    def add_interest(self):
        self.balance += self.balance * Account.rate

a = Account(1000)
b = Account(500)
Account.rate = 0.05
a.add_interest()
print(round(a.balance), round(b.balance))

1. a and b each get their own balance (instance variables): 1000 and 500.
2. Account.rate = 0.05 changes the class variable for every object, since neither of them has its own rate.
3. Only a.add_interest() is called: $1000 + 1000\cdot 0.05 = 1050$.
4. b.balance is unchanged since add_interest was never called on b.

The output is 1050 500.

Common mistakes

• Believing a class variable is private to each object. It is shared until someone sets an instance variable with the same name.
• Forgetting self as the first parameter of a regular method.
• Forgetting the parentheses for inheritance: class ElectricCar(Car):, not class ElectricCar: Car.
• Confusing __init__ (called automatically when the object is created) with a regular method you must call yourself.
• Believing that @staticmethod has access to self or the object's attributes – it does not.

Concepts in this part

Practise object orientation in the app →

2. Algorithms and data structures

What is it about?

When data grows large, it is not enough that the code works – it also has to be fast enough. Complexity analysis (Big-O) gives you a language for describing how much work an algorithm does as the amount of data $n$ grows, independent of the computer. As an engineer you need this to choose the right data structure and algorithm before the code becomes slow on real, large datasets – for example measurement series with millions of points.

Concepts and formulas

• Amortized complexity: my_list.append(x) is $O(1)$ on average, even though the list occasionally has to be copied to a larger block of memory.
• my_list.insert(0, x) and my_list.pop(0) are $O(n)$: every element behind the insertion point has to be shifted.
• A recursive function needs a base case to stop, otherwise it raises RecursionError. The number of recursive calls is often tied to the size of the input.
• Inversion: a pair of elements that are in the wrong order in a list. Insertion sort swaps neighboring elements until every inversion is gone.
• Common complexity classes from fastest to slowest: $O(1) < O(\log n) < O(n) < O(n\log n) < O(n^2) < O(2^n)$.
• Two nested loops that both run $n$ times together give $O(n^2)$ (quadratic).

How to solve the problems

1. Find which part of the code repeats the most as $n$ grows – that is what dominates the complexity.
2. Count nested loops: one loop over $n$ gives $O(n)$, a loop inside a loop gives $O(n^2)$.
3. For recursion: write out the calls until the base case is reached, and count them.
4. For sorting: follow the algorithm step by step with a concrete list, noting every comparison and every swap.

Example

Insertion sort swaps an element backward until it is in the right place, one step at a time:

def sort(a):
    swaps = 0
    for i in range(1, len(a)):
        j = i
        while j > 0 and a[j-1] > a[j]:
            a[j-1], a[j] = a[j], a[j-1]
            j -= 1
            swaps += 1
    return swaps

print(sort([3, 1, 2]))

1. $i=1$: compare $a[0]=3$ and $a[1]=1$. $3>1$, so they are swapped: $[1, 3, 2]$, swaps = 1.
2. $i=2$: compare $a[1]=3$ and $a[2]=2$. $3>2$, swap: $[1, 2, 3]$, swaps = 2. Now $a[0]=1 \leq a[1]=2$, so the inner loop stops.
3. The list is sorted, and the function returns 2.

The output is 2, which is the number of inversions in the original list (the pairs 3–1 and 3–2).

Common mistakes

• Believing that append and insert(0, x) are equally fast. They are $O(1)$ and $O(n)$ respectively.
• Forgetting the base case in a recursive function.
• Counting only the outer loop and forgetting that an inner loop multiplies the work.
• Mixing up the number of comparisons and the number of swaps in a sorting algorithm – they are not always equal.
• Believing that $O(n\log n)$ and $O(n^2)$ are about equally fast for large $n$. The difference becomes enormous.

Concepts in this part

Practise algorithms and data structures in the app →

3. Numerics with NumPy

What is it about?

NumPy gives Python fast, vectorized computation with numeric arrays – essential for engineering calculations on large datasets, such as measurement series and simulations. You will also learn basic numerical methods: Newton's method for finding the roots of a function, and Euler's method for solving differential equations approximately, step by step. try/except lets the program handle bad data without crashing.

Concepts and formulas

• np.array: the operators + - * / act elementwise, not as matrix multiplication. Use @ or np.dot for a matrix product.
• Boolean indexing: a[a > k] gives a new array with only the elements that satisfy the condition.
• Broadcasting: arrays with the same shape, or where one dimension is 1, can be combined elementwise. Different, incompatible shapes raise ValueError.
• np.mean, np.std, np.sum, a.min()/a.max(): statistics over an array.
• Newton's method: $x_{n+1} = x_n - f(x_n)/f'(x_n)$, follows the tangent line down to the root.
• Euler's explicit method: $y_{n+1} = y_n + h\,f(t_n, y_n)$ for $y' = f(t, y)$.
• try: ... except SomeError: ... catches one specific error type. A bare except: catches everything, including errors you should really have noticed.

How to solve the problems

1. Check whether the code computes elementwise or does matrix arithmetic – look for * versus @/np.dot.
2. With boolean indexing: work out the condition for every element first, then keep only the ones that are True.
3. For Newton/Euler: plug the numbers into the formula, one step at a time, and keep track of which value is $x_n$/$y_n$ for the next step.
4. Check the shapes of the arrays before adding them – do they match, or can they broadcast?

Example

A sensor logs 5 measurements. We want the mean of the measurements above 20:

import numpy as np
a = np.array([15, 24, 31, 18, 27])
above = a[a > 20]
print(above, round(above.mean(), 2))

1. a > 20 gives a boolean array [False, True, True, False, True].
2. a[a > 20] uses it to pick out the values where the condition is true: [24, 31, 27].
3. The mean is $(24+31+27)/3 = 27.33$.

The output is [24 31 27] 27.33.

Common mistakes

• Confusing * (elementwise) with @/np.dot (matrix multiplication).
• Believing that boolean indexing returns True/False values instead of the actual numbers.
• Adding arrays with incompatible shapes and being surprised by ValueError.
• Using a bare except: that catches and hides errors you should really have noticed.
• Dividing by f'(x) without checking that it is not zero or very small in Newton's method.

Concepts in this part

Practise numerics with NumPy in the app →