Numbers, Text, and Truth

Python has a handful of basic types and you will use four of them constantly: integers, floating-point numbers, strings of text, and booleans. Knowing which one you are holding prevents most early confusion.

The four you need now

count = 12               # int   — whole number, exact
learning_rate = 0.01     # float — decimal, approximate (see below)
name = "gradient"        # str   — text, in quotes
converged = True         # bool  — True or False, capitalized

print(type(count), type(learning_rate), type(name), type(converged))

Converting between them

Python will not silently convert types for you, which is a feature. `"3" + 4` is an error rather than a guess, because the interpreter cannot know whether you meant 7 or "34". Convert explicitly and the ambiguity disappears.

Explicit conversion

int("42")        # 42     — string to integer
float("3.14")    # 3.14   — string to float
str(42)          # "42"   — number to string
int(3.9)         # 3      — truncates toward zero, does NOT round
round(3.9)       # 4      — this rounds
bool(0)          # False  — 0, "", [], and None are falsy; almost everything else is truthy

Formatting text

An f-string lets you drop values directly into text. It is the only string formatting you need to learn, and you will use it in every print statement and log line you ever write.

f-strings

loss = 0.03847
epoch = 12

print(f"epoch {epoch}: loss {loss}")            # epoch 12: loss 0.03847
print(f"epoch {epoch}: loss {loss:.3f}")        # epoch 12: loss 0.038   <- 3 decimals
print(f"epoch {epoch}: loss {loss:.2e}")        # epoch 12: loss 3.85e-02

The floating-point fact

Floats are stored in binary and most decimal fractions have no exact binary representation, exactly as one third has no exact decimal representation. So arithmetic on them accumulates tiny errors.

The result that surprises everyone once

0.1 + 0.2            # 0.30000000000000004
0.1 + 0.2 == 0.3     # False

# So never compare floats with ==. Compare with a tolerance:
abs((0.1 + 0.2) - 0.3) < 1e-9    # True

Why this matters far beyond this lesson

Every number in a neural network and every joint angle in a robot arm is a float. Accumulated floating-point error is why gradient checks compare within a tolerance rather than for equality, why GPU results are not bitwise reproducible across machines, and why an ill-conditioned matrix is dangerous. You are meeting the constraint here in its simplest form.

Try each one before opening the solution. Getting it wrong first is most of where the learning happens.