Python, got it?

Python reads your code from top to bottom, one line at a time. Like a recipe: step 1 before step 2. print() shows something on the screen (the output). Lines that start with # are comments: notes for you, which Python skips.

Think of a variable as a name tag stuck on a value. When you write age = 18, Python creates the value 18 and sticks the tag age on it.

Important: = in Python does not mean "equals" like in math. It means "assign": take the value on the right and stick the name on the left to it. That's why age = age + 1 is valid (in math it would be impossible).

x = 10
y = x
x = 99
print(y)

Every value in Python has a type. The type decides what you can do with it: two numbers can be added, while two pieces of text get joined. To check a type, use type().

age = input("Your age? ")   # "18" (str)
age = int(age)               # 18 (int)
print(age + 1)               # 19

print("5" + 5)

A string is a row of boxes, one character per box. Each box has an index (its address). Counting starts at 0, not 1. You can also count from the end with negative indexes: -1 is the last character.

s = "Python"
print(len(s))        # 6
print(s.upper())     # PYTHON
print(s.lower())     # python
print(s[::-1])       # nohtyP  (reversed!)
print("th" in s)     # True

name = "Ana"
yr = 1
# f-string: put variables inside {}
print(f"Hi {name}, you're in year {yr}!")
# Hi Ana, you're in year 1!

A list is an ordered collection of values inside [ ], separated by commas. Like strings, list indexes start at 0. The difference: you can change what's inside a list. You can add, remove and reorder items.

grades = [88, 92, 75]
print(grades[0])     # 88  (first)
print(grades[-1])    # 75  (last)
grades[1] = 95       # replace index 1
print(grades)        # [88, 95, 75]
print(sum(grades))   # 258

In a list you find a value by its number (index). In a dictionary you find it by its key, like fields on a student record: key → value. Dictionaries are written with { }.

student = {"name": "Ana", "course": "BSCS", "year": 1, "scholar": True}

An if asks a question whose answer is True or False. If it's True, the block under it runs. The elifs are checked one by one, top to bottom, stopping at the first True. If nothing is True, the else block runs.

A for loop goes through each item of a list (or a string, or a range), one at a time. On every pass, the loop variable is stuck on the next item.

When you just want to repeat something a number of times, use range(). It produces a sequence of numbers, with the same rule as slicing: the stop value is not included.

snooze = 3
while snooze > 0:
    print("5 more minutes...")
    snooze = snooze - 1
print("Awake!")

for n in range(1, 10):
    if n == 3:
        continue   # skip 3
    if n == 6:
        break      # stop at 6
    print(n)
# 1 2 4 5

A function is a named block of code. You write it once with def, then call it as many times as you like. Data goes in through parameters, and the answer comes out with return.

def greet(name, course="BSCS"):
    return f"Hi {name} from {course}!"

print(greet("Ana"))           # uses the default course
print(greet("Ben", "BSIT"))   # passes its own course

Errors are normal, even for senior developers. An error message is a clue, not an insult. Read it from the bottom up: the last line names the error, and the lines above it point to the line number.

if age > 18
    print("Adult")

for x in range(3):
print(x)

name = "Ana"
print(Name)

age = input("Age? ")
print(age + 1)

nums = [10, 20, 30]
print(nums[3])

grades = []
print(sum(grades) / len(grades))

Six questions. Pick an answer to see right away whether it's correct, and why.

Time for a real program: scientific_calculator.py. It opens a window with 53 keys, shows the answer while you type, and keeps a history of your calculations. It's about 1,300 lines long, but it's built from the pieces you already learned: strings, lists, dicts, tuples, if/elif, loops and functions, plus three new ideas you'll meet soon: classes, exceptions and recursion.

By the end of this lesson you should be able to run it on your own computer, use every key, and explain to someone else how it works.

ARun it on your computer

1. Install Python 3.

   Download it from python.org. On Windows, tick “Add python.exe to PATH” on the first screen of the installer. The calculator uses Tkinter to make its window, and Tkinter comes with Python, so there's nothing else to install.

2. Put both files in one folder.

   For example Documents\calculator, with scientific_calculator.py (the app) and test_scientific_calculator.py (its tests) inside.

3. Open a terminal in that folder.

   Windows: open the folder in File Explorer, click the address bar, type cmd and press Enter. In VS Code: File → Open Folder…, then Terminal → New Terminal.

4. Start the calculator.

   > python scientific_calculator.py

   The window opens. Close it like any other window when you're done.

5. Run the tests (optional, but satisfying).

   > python -m unittest -v
   test_ans_holds_last_result (…EngineTest…) ... ok
   test_arithmetic_and_precedence (…EngineTest…) ... ok
   … 41 more …
   ----------------------------------------------------------------------
   Ran 43 tests in 4.2s
   
   OK

   Each line is one test. OK at the end means every answer the tests checked was right.

If something goes wrong

BUse it: a tour of the window

1 2 3 4 5 6 7 8 9 10

1. 1Status chips. DEG or RAD is the angle mode. M 3.14159 appears while something is saved in memory.
2. 2Show / hide history. Hiding it makes the window smaller.
3. 3Last calculation, like 2π×sin(30) =. Error messages appear here in red.
4. 4The display. Type here or use the keys. You can click inside it to edit any part. Long expressions get a smaller font.
5. 5Live preview. The answer appears while you type, before you press =.
6. 6Scientific keys: trig, powers, roots, logs and constants.
7. 7Memory keys to save a number for later.
8. 8Number pad with the four operators, brackets, clear and backspace.
9. 9Equals calculates the answer.
10. 10History. Every answer is saved here, newest first. Click one to reuse it.

What every key does

Keyboard shortcuts

CHow it works

The big picture

The engine never touches the window. That's why the tests can check over a hundred answers in a few seconds without opening it, and why the same engine could be reused in a website. (This page does that: the lab below runs a JavaScript copy of it.)

Map of the file

Follow one calculation

How does it know × comes before +?

The parser is a ladder of functions. Each rung handles one group of operators, then asks the rung below it for the pieces on each side. Lower rungs bind tighter, so they get computed first. It's PEMDAS written as code.

def expr(self):
    value = self.term()
    while True:
        if self._accept("+"):
            value += self.term()
        elif self._accept("-"):
            value -= self.term()
        else:
            return value

Things you already know, inside the calculator

KEY_STYLES = {
    "digit": {"faces": ("#252a37", "#2f3545", "#3a4153"),
              "text": "#f3f5fa"},
    "operator": {"faces": ("#2a2552", "#342e64", "#3e3777"),
                 "text": "#c9c1ff"},
    ...
}
face = style["faces"][STATES.index(state)]

_POSTFIX = {
    "!": _factorial,
    "%": lambda value: value / 100,
    "²": lambda value: _power(value, 2.0),
    ...
}
value = _POSTFIX[text](value)

def complete_parentheses(expression):
    return expression + ")" * max(
        expression.count("(") - expression.count(")"), 0)

tokens = []
pos = 0
while pos < len(text):
    if text[pos].isspace():
        pos += 1
        continue
    match = _TOKEN_RE.match(text, pos)
    ...
    tokens.append((kind, match.group()))
    pos = match.end()

self.history.append((expression, value))

# ↑ key: step back through the list
position = len(self.history) - 1
text = self.history[position][0]

if head.endswith("+"):
    return head[:-1] + "−" + number
if head.endswith(("−", "-")):
    ...
return head + "−" + number

New ideas you'll meet next

class ScientificEngine:
    def __init__(self):
        self.degrees = True
        self.ans = 0.0

engine = ScientificEngine()
engine.evaluate("2+3")   # 5.0, and engine.ans is now 5.0

try:
    result = _Parser(tokens, self).parse()
except ZeroDivisionError:
    raise CalculatorError("Cannot divide by zero") from None

self.bind("<ButtonRelease-1>", self._on_release)
self.entry.bind("<Return>", ...)
self.entry_var.trace_add("write", self._on_text_change)
...
CalculatorApp().mainloop()

How the window is drawn

Tkinter's normal buttons are plain rectangles, so the calculator draws its own keys. Each key is one picture of a rounded rectangle, plus its text, and all 53 keys sit on one big canvas. The smooth corners come from a little geometry: for each pixel near a corner, measure how far it is from the corner circle's centre. A pixel that is half inside the circle gets a half-and-half mix of the key colour and the background.

def _coverage(distance, radius):
    """How much of a pixel lies inside the circle (0 to 1)."""
    return min(max(radius - distance + 0.5, 0.0), 1.0)

Tests: code that checks code

def test_superscripts_are_postfix_operators(self):
    self.assertResults({
        "3²5": 45,   # (3²)·5, not 3^25
        "2²³": 64,   # (2²)³
        "3²!": 362880,
    })

Bugs the testing caught

Before the calculator was finished, a careful review plus 120,000 random test inputs found 12 bugs. A few of them:

Each bug became a new test, so it can never quietly come back.

DExplain it to someone else

The 30-second version

The 2-minute demo

1. Open a terminal and run python scientific_calculator.py.It's one Python file, and it only uses what comes with Python.
2. Type 2+3×4. Point at the preview = 14.It follows the order of operations, and it shows the answer before I even press equals.
3. Press =, then type ×2.If I keep going after equals, it continues from the answer, called Ans.
4. Type sin(30 and press =.It closes the bracket for me. DEG means degrees; this button switches to radians.
5. Type 1÷0 and press =.Errors show a message instead of crashing. In the code, that's try and except.
6. Click an answer in the history panel.Every answer is saved in a list, and clicking one reuses it.
7. Open the code at _tokenize, then expr.First the text is cut into tokens. Then the parser is a ladder of functions, one for each level of the order of operations.
8. Run python -m unittest -v.These 43 tests check more than a hundred answers in a few seconds, so I know a change didn't break anything.

Questions people might ask