Upon completion of this lesson you should:
* and /The software industry is obsessed with code being “open-source”. The Free Software Foundation is one of the leading organization behind this movement if you’d like to learn more. There is an expression that “free software” means “free as in freedom” not “free as in beer”. However, that fact that all open-source software is by definition also “free as in beer” surely helps this movement. The entire modern world depends on “open-source” software. For instance, every single website is run using the Linux operating system with Apache webservers and mySQL databases, and so on.
Note that UWaterloo used to use Matlab for teaching programming, but we shifted to Python about 5 years ago. Matlab is an excellent product, but it is not open source and it is not free.
There are literally thousands of programming languages. They are called ‘languages’ because they all have their own “words” and “grammatical rules”, known as syntax. Each language was created for a specific reason, and each offers their own special features. Some reasons for choosing one language over another are:
Python has a checkmark beside nearly every box. Vanilla Python has quite slow performance but there are many ways to address this, some of which we will cover in this course.
Perhaps the main reason to learn Python right now is that it is by far the most popular general purpose programming language in the world today. This means (a) there is loads of support available, (b) a massive ecosystem of packages to add functionality (e.g. PyTorch is the leading machine learning framework and it is designed for use in Python), and (c) employers will expect you to know Python.
What are the tools you associate most closely with the job of “engineer”? Probably a calculator!
Throughout these notes (and the internet in general) you’ll see computer programs (often referred to as “code”) written in the following format:
print() statement is actually run and the output is printed below.
some textAlso, the grey background is used to indicate a code block. And you’ll notice an icon in the top-right corner, which will “copy” the contents of the block so you can paste it into your own program.
Have you ever had to do an extremely boring but repetitive task? Computers were literally invented to solve that problem!
Many non-technical people still have to deal with data, so they will seek help from engineers (such as yourselves). There are many tools to help us make ‘user-interfaces’ so normies can interact with a computer. Even Facebook is arguably just a web-based user interface for a social network graph.
Example 2.3 (Develop a graphical user interface for simulating a hydrogen fuel cell) There are many, many frameworks available for making graphical interfaces so users can interact with a computer program. Some are extremely powerful but hard to use, while others offer basic features but are super easy. Streamlit is one of my favorites. It is very fast to learn, requires only pure Python, and renders in the web browser.
Solution
Comments
You can play with this app here.
Good news: you will be using Streamlit to make your own app for the project in this course!
“To begin, begin”
- William Wordsworth
First let’s look at mathematics, since this is one of the most common uses of Python for engineers. In “real” mathematics we use symbols like \(\times\) and \(\divsymbol\), but we do not have these on our keyboard, so we had to improvise. The following table lists the keys for each mathematical operation.
** is for exponentiation in Python, but if you accidentally use ^ like Excel you will not get an error but the wrong answer)
| Symbol | Operator | Example Expression | Resulting Value |
|---|---|---|---|
- |
negation | -5 | -5 |
+ |
addition | 11 + 3.1 | 14.1 |
- |
subtraction | 5 - 19 | -14 |
* |
multiplication | 8.5 * 4 | 34.0 |
/ |
division | 11 / 2 | 5.5 |
** |
exponentiation | 2 ** 5 | 32 |
// |
integer division | 11 // 2 | 5 |
% |
remainder | 8.5 % 3.5 | 1.5 |
What about the famous \(\sqrt 2\) sign you ask? We will have to remember our high school math rules and use 2**0.5.
Below are some snapshots of these operators in action:
11 + 31411.4944 + 3.000214.49465 - 9-410/25.02**16655362**-0.50.7071067811865476But we will do a lot more with Python that just math. Every single symbol (except 2!) on a standard QWERTY keyboard is used for something in Python. We will cover almost all of these, but below is an introductory summary:
| Symbol | Name | Use(s) |
|---|---|---|
. |
Period | The normal decimal point, namespace demarcation |
, |
Comma | Used to separate items in a list…not like 1,000,000! |
_ |
Underscore | When used in a number it acts like a traditional comma |
<, > |
Angled Brackets | “Less than” and “greater than” |
= |
Equal Sign | Used for variable assignment…not equivalency!! |
== |
Double Equal | Used to check if two things are equivalent |
!= |
Exclamation Mark | Used to check if two things are not equivalent |
* |
Asterisk | Multiplication, arg unpacking |
** |
Double Asterisk | Exponentiation, kwarg unpacking |
+ |
Plus Sign | Addition, concatentation (joining things) |
- |
Minus Sign | Subtraction |
% |
Percent Sign | Modulus (Integer division) |
/ |
Forward Slash | Normal Division |
( ) |
Round Brackets | Indicates a tuple, encloses function arguments |
[ ] |
Square Brackets | Indicates a list, used for indexing into containers |
{ } |
Curly Braces | Indicates a dict or a set |
: |
Colon | Has quite a few uses, usually to end a statement |
# |
Hash Tag | Indicates the following text is a comment, not code |
\\ |
Backslash | Line continuation or escape character within text |
@ |
“At” Symbol | An operator for matrix multiplication (b=A@x) |
~ |
Tilde | Bitwise complement (~1001 becomes 0110) |
', " |
Single, Double Quotes | Used to denote a string of letters |
& |
Ampersand | Means and for comparing if two things are both true |
| |
Pipe | Means or for comparing if either of 2 things are true |
; |
Semi Colon | Will prevent a line from printing to terminal |
? |
Question Mark | This one is actually unused! |
$ |
Dollar Sign | This one is actually unused, but is not always present |
We will introduce data types more thoroughly in the next chapter, but there is an important point to be made here: there is a difference between 1 and 1.0, and "1".
1 is an integer or whole number because it has no decimal place. In Python we call this an int. We know that adding and multiplying whole numbers will result in another whole number, such as 1 + 3 = 4. However, if one of the numbers is a float then Python will convert everything in the expression to a float, like 1 + 2 + 3.0 = 6.0
1.0 has a decimal so is no longer an integer. Since there is no word in English or “not an integer”, computer programmers refer to this as a “floating point number”, referring to the decimal point. In Python this is called a float. We know that division of two numbers might result in a number with a decimcal point, like 1/2 = 0.5. Python automatically converts both number to a float if the operation might return a float so that we don’t lose an information by discarding the numbers after the decimal place.
"1" is not even a number, it’s just the text for the number 1. This data type is called a “string” (as in string of characters) or str in Python. Obviously if we attempt to do math with the character "1" Python will not do what we want. In fact, if we attempt to multiply "1" by 2, Python will give us "11", which actually makes some sense if you think about it.
This last example is perhaps the best demonstration of why data type matters: So Python “knows” how to handle operations on each variable.
Operator precedence in Python is based upon the same concepts used in actual math:
| Precedence | Operator | Operation |
|---|---|---|
| 1 (highest) | ** |
exponentiation |
| 2 | - |
negation |
| 3 | *, /, //, % |
multiplication, division, integer division, remainder |
| 4 (lowest) | +, - |
addition, subtraction |
Using these precedence rules, operators of higher precedence are evaluated before those with lower precedence. In order to specific a desired order of evaluation we may use parentheses or round brackets: ().
There are many ways of installing Python. One can download the official installer, or install a code editing package that comes with Python pre-bundled (e.g. Spyder or Positron), or use the popular VSCode then add Python support though a plug-in.
For our purposes, we will do the following:
Spyder is called an “Integrated Development Environment” or IDE. This means it is a single piece of softare (an Environment) used for doing computer programming (Development) that includes a text editor, documentation, terminal, and other helpful features all in one place (Integrated).
When we open Spyder we will see the following:
tools/preferences/keyboard shortcuts.
| Key or Character | Result |
|---|---|
F5 |
Runs an entire file, putting result in console |
F9 |
Runs current line or highlighted selection |
# %% |
Creates a new cell in a file |
Shift-Enter |
Runs current cell |
Ctrl-Enter |
Runs current cell and advances to the next one |
Ctrl-Up Arrow |
Moves cursor to preceeding cell |
Ctrl-Down Arrow |
Moves cursor to next cell |
Ctrl-L |
Clear terminal |
Alt-Up/Down Arrow |
Moves current line up/down |
Ctrl-Alt-Up/Down |
Duplicates current line up/down |
Tab or Ctrl-Space |
Open “Suggested Completions” |
Ctrl-i |
Open documentation for selected item |
When your cursor is in the terminal, you can press the up arrow to scroll previous commands. This is normal at most terminals. Spyder offers an extra feature: if you type a letter (i.e. p) the press the up arrow it will only show you previous commands that started with p. This is a massive time saver for repeatedly calling something like a plot command.
So far we have used Python like a dumb calculator that just prints out an answer. It becomes a lot more useful once we store the result of each calculation for later use. For instance:
a = 9
b = 2
c = a / b
print(c)4.5The main thing to note here is that = sign does not mean “equals”! It is better to think of it as gets, as in a gets 9. Or is assigned as in a is assigned 9. As we will see in Section 4.1, equality is checked with ==.
x = x + 5 it does not mean that the world has gone mad.x == x + 5 you are correct to think the result is False.For comparison, the language R avoids this confusion by using arrows to denote the assignment of values like:
x <- 1.0 # This does not work in Python :-(which very clearly means that the value of 1.0 is being written to the variable x. Interestingly, this notation allows things to work in both directions too, like:
1.0 -> x # This does not work in Python :-(Python technically could support this notation since the -> and <- key combinations are not assigned to anything. Maybe someone will write a pep for this.
Another example of storing items in variables is for declaring constants:
T at the top of the file where it’s easy to find
T to get the pressure P. Of course we must not overwrite T before step 2!
An interesting conundrum occurs when we wish to swap values between two variables:
A = 4
B = 10
temp = A
A = B
B = temp
print("The value of A is now:", A)
print("The value of B is now:", B)The value of A is now: 10
The value of B is now: 4The key point is that a temporary variable must be created to store A. This is like swapping two objects on a shelf with only one hand. If you try this, you will realize that you need to put one item down in a temporary location while you move the other one. Then you can pick up the first item and finish the transfer.
Python includes a fairly long list of “built-in” functions, a subset of which are given in Table 2.5. Many of these will be gibberish (for now), but there are a few which we should recognize, such as abs(), round() and pow().
| Function | Description |
|---|---|
abs() |
Returns the absolute value of a number |
complex() |
Returns a complex number |
divmod() |
Returns the quotient and the remainder when argument1 is divided by argument2 |
float() |
Returns a floating point number |
help() |
Executes the built-in help system |
int() |
Returns an integer number |
pow() |
Returns the value of x to the power of y |
print() |
Prints to the standard output device |
round() |
Rounds a numbers |
type() |
Returns the type of an object |
Python itself has a limited set of functions, like those shown in Table B.1. One of the reasons Python is especially useful are the many, many external libraries that have been written for it. In some ways, Python has benefited from the network effect, where people write libraries for Python because it has the most libraries, and so on.
Some packages are used commonly enough that Python includes them within itself. This set of extra packages is called the Standard Library. These packages contain functions which are not core to Python, but are important enough that they are officially supported by the Python team, and are available in every normal Python installation.
A prime example is the math package. It provides a huge variety of extra mathematical functions, essentially turning our standard calculator into a scientific calculator.
The Python Package Index is home to over 0.5 million packages. These are not included in the Standard Library so we need to install them. There are several ways to do this, but they will be discussed later in the course.
Accessing these extra powers is easy:
from math import sin, pi
sin(pi/4)0.7071067811865475We can also import the entire math libary and then access each of the sub-functions as follows:
import math
1math.sin(math.pi/4). is used to indicate that you are accessing items below the math library. This is like a . in a section number: 1.2.a, where each indicates a new level of depth.
0.7071067811865475When we import the entire math library using import math, we then access all the functions using math.tan(). The word math is called the namespace under which all the math functions are available. Importing the entire library prevents collisions between two functions that have the same name.
The following will cause a problem:
from math import tan
from colors import tan # This is not a real package!While this approach is safe:
import math, colors
# Then we access the respective tan functions as:
math.tan()
colors.tan()There is one more useful feature of namespaces: you can choose which namespace you want to import a library as, called an alias:
import math as m
# Now we can save type 3 letters:
m.tan()The math package has a lot of functions in it. How do you know what functions are available and what they are called? For example, what if you can’t remember if it’s called acos or arccos? Use tab/ctrl-space in Spyder to the autocompletion menu!
math package, it also shows the help window (for the acos function) in the top right.
In addition to the built-in functions, and the massive collection of extras we can install and import, we will still want to create our own custom functions. The construction of such a function requires very little extra code:
def means define as in define a function. (2) We will call our function sqrt, which is the name we will use when we call it. (3) Inside the round brackets we list all the variables that our function requires.
:! Whitespae like this crucial in Python. Refer to here: Important 2.1 for more info.
Python is quite flexible about many things, but it is not flexible about whitespace at all!. When Guido van Rossum created Python in 1991 he had several guiding principles. One of them was the realization that “code is read more often than it is written”. For this reason he designed the syntax to use whitespace to denote logical blocks rather than brackets and braces like other languages (i.e. C/C++). The mandatory indentation makes code quite easy for a human to read since the logical blocks are instantly identifiable.
As a general rule, you should add 4 spaces each time you use a colon :, then cease adding the spaces when the block is finished.
We can use this function in our program as follows:
a has nothing to do with the variable name x inside the function.
y inside the function, does not mean that y is available outside the function. The numerical value gets returned, not the variable y. We catch the value of 3 and assign it to any variable name we like, in this case c.
As our programs get larger we may wish to “declutter” our scripts. One of the first things we can do is to move all our function definitions to a second file (and place that file in the same directory as our script). So if our main program is in a filed called main.py, we would create a second file funcs.py (or whatever you want). Then in our main.py file we would write:
from to tell Python where to look, then we import roots.roots function is imported into our file, we can use it as if it was defined inside the file.
Note that we could also do from funcs import * which would import all functions in funcs.py, since the * acts as a “wildcard” meaning “anything”. We could also do import funcs, then use funcs.roots() in our function.
Copy and paste the following code to a new .py file in Spyder and work through each cell until you get the desired result.
# %% Problem 1: Basic Arithmetic Operations
#
# Write a Python expression with one command to calculate
# the remainder when variable A is divided by B.
#
# Complete the code below:
A = ''
B = ''
remainder = ''
print("The remaidner is:", remainder)
# %% Problem 2: Variable Assignment - Displaying Data
#
# Assign the values "Hello" to the variable `greeting`
# and "World" to the variable `target`. Then print the
# result in one line to be "Hello World".
#
# Complete the code below:
greeting =''
target = ''
print('', '')
# %% Problem 3: Variable Reassignment
#
# Assign the value 10 to a variable `x`. Then, update `x`
# by multiplying it by 5 and subtracting 3. Print the
# final value of `x`.
#
# Complete the code below:
x = ''
print("The final value of x is:", x)
# %% Problem 4: Swapping values between variables
#
# Assign 10 to x and 20 to y, then swap the values such
# that y holds 10 and x holds 20 and print the result.
#
# Complete the code below:
x = 10
y = 20
print('The new values of x and y are:', x, 'and', y)
# %% Problem 5: Developing longer mathematical expressions
#
# Write an expression that converts a temperature to
# Fahrenheit using the formula F = (9/5) * C + 32 and
# print the result.
#
# Complete the code below:
celsius = 22.0
fahrenheit = ''
print("The temperature in Fahrenheit is:", fahrenheit)
# %% Problem 6: Using the `math` library
#
# Import the `math` library and calculate the following:
# 1. The value of 4.3 after rounding UP
# 2. The value of rounding DOWN
# 3. The logarithm (base 10) of 1000.
#
# Hint: You can use "Google" to find information
#
# Complete the code below:
import math
rounded_up = ''
rounded_down = ''
log_value = ''
print("Ceiling of 4.3:", rounded_up)
print("Floor of 4.8:", rounded_down)
print("Logarithm (base 10) of 1000:", log_value)
# %% Problem 7: Custom functions
#
# Define a function `nth_root` that takes a number and
# a root, and computes the nth root:
#
# Complete the code below:
def nth_root():
pass
# Test the function
print("The 5th root of 3 is:", nth_root())
print("The square root of 8.8 is:", nth_root())
# %% Problem 8: Functions that return 2 values
# Write a function that:
# 1. Accepts the radius of a circle.
# 2. Imports the `math` module to use π.
# 3. Returns both the area and circumference of the circle.
#
# Print the results in one line.
#
# Complete the code below:
def area_and_circumference():
pass
# Test the function
radius = ''
area, circumference = area_and_circumference()
print("The area is:", area)
print("The circumference is:", circumference)