Numbers and arithmetic

The arithmetic operators

spend = 1250.50
clicks = 500
print("Cost per click:", spend / clicks)
print("Spend doubled:", spend * 2)

Python has two kinds of number:

• Integers (int) are whole numbers, like 500.
• Floats (float) have a decimal point, like 1250.5.

Mix them in a calculation, and the result is a float. Division with / always gives a float, even when it divides evenly:

print(10 / 2)
print(type(10 / 2))

Long numbers are easier to read with underscores, which Python ignores: impressions = 1_250_000.

Order of operations

Python follows the order you learned in school:

1. ** first,
2. then *, /, // and %,
3. then + and -.

Operators at the same level go left to right. Parentheses override all of it. Use them whenever the order matters, even if you think Python would get it right anyway. They make your meaning obvious to the next reader.

revenue = 15840
cost = 3120.5

wrong_margin = revenue - cost / revenue     # divides first, then subtracts
margin = (revenue - cost) / revenue         # what we actually meant

print(wrong_margin)
print(margin)

print(2 + 3 * 4)

Whole batches and what's left over

// and % answer two questions that come up all the time: how many whole groups fit, and how many are left over. Think of packing eggs into boxes of 12. // counts the full boxes, and % counts the eggs left over.

Say an email platform sends in batches of 500:

Powers and rounding

** raises a number to a power. It's how you model compounding, such as a channel growing 5% a week:

weekly_signups = 1000
growth = 1.05
print(weekly_signups * growth ** 4)    # four weeks of 5% growth

round(number, digits) rounds to that many decimal places. With no second argument it rounds to a whole number and gives back an int:

ctr = 0.034782
print(round(ctr, 3))
print(round(ctr * 100, 1))   # as a percentage
print(round(1157.625))

Why 0.1 + 0.2 isn't 0.3

Try this:

print(0.1 + 0.2)

This isn't a bug in Python. Computers store floats in binary, using only 0s and 1s. Most decimal fractions, 0.1 included, can't be written exactly in binary. It's like how 1/3 can't be written exactly in decimal (0.3333...). Python stores the closest value it can, and tiny differences sometimes show up.

In practice:

• Round when you display results. round(0.1 + 0.2, 2) is 0.3.
• Don't expect two floats calculated differently to be exactly equal. You'll see how to compare them safely in the conditionals lesson.
• Systems that handle money often store whole cents as integers to avoid the issue entirely.

Watch out: round() rounds an exact half to the nearest even number, so round(2.5) is 2 and round(3.5) is 4. It rarely matters for reporting, but it explains results that look off by one.

Converting between text and numbers

Data from a spreadsheet export, a web form or an API often arrives as text, even when it looks like a number. You saw in the last lesson that "5000" + 100 fails. Three functions convert between types:

budget_text = "5000"          # text, perhaps read from a file
budget = int(budget_text)     # now a number
print(budget + 100)

price = float("19.99")
print(price * 3)

print("Clicks: " + str(120))  # + joins text, so the number must become text first

int() of a float drops the decimal part instead of rounding: int(3.9) is 3. And int() refuses text that isn't a clean whole number:

print(int("19.99"))

Use float("19.99") for text with a decimal point. Text such as "1,200" fails in both, because of the comma. The strings lesson shows how to remove it first.

spend_text = "2390.75"
revenue_text = "3290"
conversions_text = "47"

spend = float(spend_text)
revenue = float(revenue_text)
conversions = int(conversions_text)

roas = revenue / spend
cpa = spend / conversions

print("ROAS:", round(roas, 2))
print("CPA:", round(cpa, 2))

print(int(7.8))

Results that surprise people

A few of Python's arithmetic rules catch almost everyone once.

Division always gives a decimal. 10 / 2 is 5.0, not 5, even though the answer is whole. The type of result doesn't depend on the numbers you happened to use, which makes programs more predictable. If you want a whole number, use //.

int() cuts, it doesn't round. int(3.9) is 3. Python drops everything after the point. For a rounded answer, use round(3.9), which gives 4.

print(10 / 2)
print(int(3.9), round(3.9))

Order of operations still applies. Suppose revenue is 200 and cost is 150, and you want the margin. Writing revenue - cost / revenue gives 199.25, because the division happens first. What you meant needs brackets: (revenue - cost) / revenue, which gives 0.25. When a result looks odd, check the brackets before anything else.

int() is picky about text. int("42") works, but int("3.5") and int("twelve") stop with a ValueError. Text with a decimal point has to go through float() first. This matters as soon as your numbers come from a form or a file, because those always start out as text.