Variables, types and expressions

Most engineering programs start the same way: take some numbers, combine them with formulas, and report the result. This chapter covers the building blocks for doing that well: variables to hold values, the basic types of data Python works with, arithmetic and the order of operations, the math module, converting between types, reading input and formatting output.

It also explains one of the most surprising facts about computing for newcomers: computers cannot store most decimal numbers exactly. Understanding why prevents a whole class of subtle bugs. Throughout, the examples are calculations you have met in first-year courses: stresses, flows, unit conversions and pendulums.

Variables and assignment

A variable is a name that refers to a value. You create one by assignment, with a single equals sign:

span_m = 6.0
load_kN = 12
material = "steel"
print(span_m, load_kN, material)

The right-hand side is evaluated first, then the name on the left is made to refer to the result. That is why count = count + 1 makes sense in code even though it is nonsense in algebra: take the current value, add one, and store the new value under the same name.

Python variable names may contain letters, digits and underscores, must not start with a digit, and are case-sensitive (Load and load are different). They cannot be one of Python's reserved words such as if, for, or class. Good names describe the quantity and its units: wall_thickness_mm, not t or x1. Constants, values that should not change, are by convention written in capitals: G = 9.81.

The basic types

Every value in Python has a type, which decides what you can do with it. Four types cover most engineering calculations:

• int: whole numbers, of any size: 12, −3, 1000000.
• float: numbers with a decimal point or exponent: 6.0, 0.001, 2.1e11 (which means 2.1 × 10¹¹, a typical Young's modulus for steel in pascals).
• str: text (strings), in single or double quotes: "steel", 'W310x39'.
• bool: the truth values True and False, the result of comparisons such as stress < allowable.

print(type(3), type(3.0), type("3"), type(True))

<class 'int'> <class 'float'> <class 'str'> <class 'bool'>

Notice that 3, 3.0 and "3" are three different things. The first two are numbers that happen to be equal; the third is a piece of text containing the character 3, and arithmetic on it behaves very differently.

Arithmetic and the order of operations

Python's arithmetic operators are:

• + addition, − subtraction, * multiplication, / division (always gives a float).
• ** exponent: 2 ** 10 is 1024; 10 ** 0.5 is the square root of 10.
• // floor division: divides and rounds down to a whole number.
• % remainder (modulo): what is left after floor division.

The order of operations is the usual one from mathematics: brackets first, then exponents, then multiplication and division (including // and %), then addition and subtraction. Operators of equal precedence work left to right, except ** which works right to left.

print(7 / 2, 7 // 2, 7 % 2, 2 ** 10)
print(2 + 3 * 4 ** 2, (2 + 3) * 4 ** 2, -2 ** 2)

3.5 3 1 1024
50 80 -4

The last result surprises many people: -2 ** 2 is −4, because the exponent is applied before the minus sign. Write (-2) ** 2 if you mean 4.

The math module

Functions such as square roots, trigonometry and logarithms live in the math module, which you load with import math at the top of a program. You then write math.sqrt(x), math.sin(x), math.log(x) (natural log), math.log10(x), math.exp(x), and use the constants math.pi and math.e.

Angles are in radians

Python's trigonometric functions work in radians, like almost all programming languages. Passing degrees gives a wrong answer with no error message: a classic logic error.

import math
print(math.sin(30))
print(math.sin(math.radians(30)))

-0.9880316240928618
0.49999999999999994

The first line computes the sine of 30 radians, which is meaningless here. The second converts 30° to radians first and gets 0.5 (to within rounding, a point we will come back to). Use math.radians() and math.degrees() to convert. When an engineering calculation with angles gives a strange answer, check this first.

Engineering formulas in code

Floating-point numbers are approximate

Here is something every engineer who programs must understand:

import math
print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(math.isclose(0.1 + 0.2, 0.3))

0.30000000000000004
False
True

Computers store floats in binary, in a fixed number of bits (64 for a Python float, following the IEEE 754 standard). Just as 1/3 cannot be written exactly as a finite decimal (0.3333…), most decimal fractions, including 0.1, cannot be written exactly in binary. The stored value is the nearest binary fraction, accurate to about 15 or 16 significant digits. The tiny representation errors usually do not matter, but they show up in two ways:

• Printed results with long tails, such as 1723.6892500000001 in Lesson 1 or 0.49999999999999994 above.
• Equality tests that fail. Never test floats for exact equality with ==. Use math.isclose(a, b), or check that abs(a − b) is smaller than a tolerance you choose.

Sixteen significant digits is far more precision than any engineering input has, so for nearly all engineering work floats are entirely adequate. Problems arise in special cases: subtracting two nearly equal large numbers (which wipes out the significant digits), summing millions of tiny values, or money, where exact cents matter (Python's decimal module handles that).

Strings

Strings hold text: labels, file names, messages, identifiers such as section designations. A few operations are enough to start:

• + joins strings: "W310" + "x39" gives "W310x39".
• len(s) gives the number of characters.
• Methods such as s.upper(), s.lower(), s.strip() (remove spaces at the ends) and s.replace("x", "X") return modified copies.

Mixing strings and numbers in arithmetic is an error: "Load: " + 12 raises a TypeError. Convert first, or better, use an f-string.

Formatting output with f-strings

An f-string is a string with an f before the opening quote. Expressions inside braces are evaluated and inserted, and a format specification after a colon controls how numbers look.

import math
period_s = 2 * math.pi * math.sqrt(1.5 / 9.81)
Re = 179640.0
print(f"Period: {period_s:.3f} s")
print(f"Reynolds number: {Re:,.0f}")
print(f"Reynolds number: {Re:.3e}")
print(f"{'Load':<8}{'Stress':>10}")
print(f"{12:<8}{30.0:>10.1f}")

Period: 2.457 s
Reynolds number: 179,640
Reynolds number: 1.796e+05
Load        Stress
12            30.0

The common specifications: .3f for three decimal places, .3e for scientific notation with three decimals, a comma for thousands separators, and < or > with a width to align columns left or right. Round only when displaying; keep full precision in the variables.

Input and type conversion

The input() function shows a prompt and waits for the user to type something. It always returns a string, even if the user types digits. To do arithmetic, convert with int() or float():

span_text = input("Span in metres: ")     # user types 6.5
span_m = float(span_text)
print(f"Half the span is {span_m / 2} m")

Converting the other way, str(30.0) gives the text "30.0", and int(7.9) gives 7 (it truncates; use round(7.9) to get 8).