From Algorithms to Python

Apply

Describe engineering problems with flowcharts and pseudocode, and solve them with programs.

Quiz · Test · Final exam

Formulate

Use an advanced scientific language for data processing, analysis and visualisation.

Quiz · Assignment · Final exam

Communicate

Read, write and compile technical documents about your work.

Assignment (group project)

Assessment

SPACE dates for the quizzes, test and project are announced in class and on e-learning.

Anaconda + Spyder

Anaconda Distribution installs Python, Spyder, NumPy, SciPy, Matplotlib and pandas in one go. It's about 1 GB, so download it on good Wi-Fi.

anaconda.com → Download → open Spyder

Spyder on its own

The Spyder standalone installer brings its own Python and the main scientific libraries. It's a smaller download.

spyder-ide.org → Download

Turning a page, as steps

1. Lift your hand.
2. Move it to the right side of the book.
3. Grasp the top-right corner of the page.
4. Move your hand from right to left until the page is turned.
5. Let go of the page.

Walking, baking a cake and solving a maths problem all happen in a set order too.

The words we'll use

• Computer: a programmable electronic device that can store, retrieve and process data.
• Program: the list of steps a computer performs to solve a problem.
• Programming: describing, or writing, those steps.

A good algorithm…

• is precise and unambiguous: each step has exactly one meaning.
• has a finite number of steps: it always stops.
• produces the correct result.
• doesn't depend on a programming language: you can code it in Python, MATLAB or C.

Last semester's test asked for two of these with a short explanation of each (4 marks).

A good flowchart

• has one start and one end;
• has flow lines that don't cross;
• contains no programming-language code;
• is neat and easy to follow.

Its drawbacks

• It takes time to draw properly.
• A large flowchart can be hard to translate into a program. That's why pseudocode is often preferred for big problems.

The notation we use

Example: IntegerDivision

Divide n by d using only subtraction: count how many times d fits into n.

procedure IntegerDivision
input : n, d
output: result
begin
    result ← 0
    while n ≥ d
        n ← n − d
        result ← result + 1
    end while
    return result
end

Compiled or interpreted?

Compiled (C, Fortran): the whole program is translated to machine code first, so it runs fast, but every change needs a rebuild. Interpreted (Python, MATLAB): statements run one by one, so you can try ideas instantly in a console. It's slower in plain loops, but libraries like NumPy do the heavy work in compiled code.

During the break

If you're installing Spyder, start the download now. After the break we write Python, and you can use either Spyder or this page.

Editor

Write and save scripts (.py files). F5 runs the whole file; F9 runs the selected lines.

IPython console

Type one command and see the answer at once. Use it to test small ideas. %whos lists your variables.

Variable explorer

Shows every variable with its type, size and value, like MATLAB's workspace.

Console or script?

The console is for trying things out, and it forgets everything when you restart. A script is a file you can save, rerun, fix and hand in. Anything you want to keep goes in a script.

Other tools you'll see

Code editors such as VS Code, Notepad++ and Sublime Text; IDEs such as PyCharm, Spyder and Jupyter notebooks. They all run the same Python.

Prompt precisely

Give the inputs with units, the output you want, and the limits ("only the math module"). A vague prompt gets vague code.

Trace it

Read every line. If you can't explain a line, ask the AI to explain it, or don't use it.

Check one case by hand

Run it on numbers you can work out yourself. AI code often runs fine and is still wrong.

Naming rules

• Use letters, digits and _ only, with no spaces or dashes.
• Don't start with a digit.
• Names are case-sensitive: R and r are different.
• Keywords aren't allowed: if for while class def True None and or not lambda …
• Avoid built-in names like sum max list print. Python allows them, but then the built-in stops working.

Style: snake_case for variables (load_current), and UPPER_CASE for values you mean to keep constant (SPEED_OF_LIGHT = 299792458). Python doesn't enforce constants; it's a convention.

Watch out for

• int() truncates; it doesn't round.
• bool("0") is True: any non-empty text is True.
• round(2.5) gives 2, because Python rounds halves to the nearest even number.
• "12" + 3 is a TypeError: convert first.
• There's no conversion to None: you just assign x = None.

Worked example

x = (6 * 2) >= 10 + 2 != 15
x = 12 >= 12 != 15         # brackets, then +
x = (12 >= 12) and (12 != 15)   # chained
x = True and True
x = True

Write every step like this in the test. The steps carry marks, not just the final answer.

Next

The numbers engineers actually use: why 0.1 + 0.2 isn't 0.3, complex impedance, and the math module. Then you build a small calculator.

Rules of thumb

• Never test floats with ==. Use math.isclose or a tolerance.
• Expect tiny errors in the last digits, and round only when you print: f"{x:.3f}".
• int is exact and unlimited; float goes up to about 1.8 × 10³⁰⁸.
• 1.2e3 means 1.2 × 10³, and 4.7e-6 means 4.7 µ: handy for component values.

Where do inf and nan come from?

• inf: a result too big for a float.
• nan: an undefined result, such as inf − inf, 0 × inf or inf / inf. Any arithmetic with nan gives nan.
• Dividing by zero: plain Python stops with a ZeroDivisionError. NumPy (Chapter 3) gives inf or nan with a warning instead.

Notes

• Write 4j, or 1j on its own. Plain j is just a variable name.
• (3 + 4j) / (1 − 2j) = −1 + 2j. Check it by hand: multiply the top and bottom by the conjugate (1 + 2j).
• The math module is for real numbers only; use cmath for complex ones.
• cmath.rect(r, θ) goes back from polar to rectangular form.

procedure ⟨Name⟩
input : ⟨inputs⟩
output: ⟨answer⟩
begin
    ⟨answer ← 0 or 1⟩
    while ⟨condition⟩
        ⟨update answer⟩
        ⟨move on⟩
    end while
    return ⟨answer⟩
end

One row per pass, one column per variable. Stop at the first ✗: that row gives the answer.

Name the characteristic, then one sentence on why it matters: unambiguous (each step has one meaning), finite (it always stops), correct (right result), language-independent (any language can code it).

Oval = start/end · parallelogram = input/output · rectangle = process · diamond = decision (Yes/No) · circle = connector · arrow = flow.

import math                    # cmath for complex
⟨x⟩ = ⟨value⟩               # inputs, units in comments
⟨y⟩ = ⟨formula⟩             # one line per formula
print(f"⟨y⟩ = {⟨y⟩:.3f} ⟨unit⟩")

Powers are **; trig takes math.radians(deg); 50 mH → 50e-3.

import math, cmath
w = 2 * math.pi * ⟨f⟩
Z = ⟨R⟩ + 1j*w*⟨L⟩ - 1j/(w*⟨C⟩)
print(abs(Z))                         # magnitude
print(math.degrees(cmath.phase(Z)))   # angle, degrees

Quadratic roots: r = cmath.sqrt(b**2 - 4*a*c), then (-b ± r) / (2*a).

1. Brackets first.
2. ** (right to left), then unary −.
3. * / // %, then + −, left to right.
4. Split a comparison chain: a >= b != c → (a >= b) and (b != c).
5. not, then and, then or.

Write one line per step: the steps carry the marks.

Design before you code

Problem solving → implementation → maintenance. An algorithm is unambiguous, finite, correct and language-independent. Write it as a flowchart (oval, parallelogram, rectangle, diamond) or as pseudocode, and verify it with a trace table.

Languages

Fortran and C/C++ are compiled and fast; MATLAB and Python are interpreted and quick to work in. Python with NumPy and SciPy is free and widely used, so it's what we use.

Python basics

A variable is created by assignment and names are case-sensitive. The types are int, float, complex, str, bool and None. / gives a float, // rounds down, % is the remainder and ** is power. Precedence: brackets, then arithmetic, comparisons, not, and, or.

Numbers for engineers

Compare floats with a tolerance; inf and nan exist. Complex numbers use j, with abs and cmath.phase. The trig functions in math work in radians.

Get ready

• Install Anaconda or Spyder on your laptop, and bring the laptop next time.
• Redo the four lab tasks in Spyder and save them as .py files, or ⬇ download today's notebook and work through every ✏️ question in Colab.
• Draw the flowchart for SumEvenNumbers (sum of 2, 4, 6, … up to n) and trace it for n = 6. You should get 12.