Python Expressions: Beginner

Run price = 10 and Python does 3 things. It builds an integer object holding 10 somewhere in memory, it records that the object's type is int, and it attaches the name price to that object. The name is a label stuck on the outside; the object is the thing that takes up space. Keeping the label and the object apart explains almost everything else in this lesson.

Sizes as reported by CPython 3.9 on a 64-bit machine. A 2-character string costs 2 bytes more than an empty one; the other 49 bytes are the object's bookkeeping.

A float always fits in the same fixed number of bits, so there's a largest value it can hold and a limit to how many digits it keeps. An int has no such ceiling. When a whole number outgrows the bytes it started with, Python allocates a bigger object for it, so arithmetic on huge integers stays exact.

The integer keeps all 31 digits, including the 1 added at the end. The float prints as 1.2676506002282294e+30, meaning 1.2676506002282294 times 10 to the power 30. Subtracting 2.0 ** 100 back out leaves 0.0, so the added 1 never reached the stored value. A float holds about 16 significant digits and spends them on the leading part of the number, which means the tail is rounded away. In data work, counts of rows and bytes are whole numbers, and so are timestamps, which is why they're kept as int for as long as possible.

Assignment with a name on the right side copies the arrow, never the object. After saved = price, both names point at the same integer, and nothing has been duplicated. When price is later assigned 20, Python points price at an object holding 20: a pre-built one for a small number like this, a freshly built one for a larger number. Either way only the price arrow swings, and saved keeps pointing where it always did. Step through the run below and watch each name move.

The final 3 lines make the same point with text. label + "!" builds a brand new string "ok!", then the name label is moved onto it. The original "ok" object is unchanged, because + builds its result separately and never edits the string it read from. An object that nothing refers to any more is freed, and its bytes are reused.

In stock = stock - 5 the same name sits on both sides. Python evaluates the right side first, using the object stock points at now, and only then moves the name onto the result. Tracing a program means noting where each name points after every line, as in this table.

A name is the label you stick on an object. Python lets you spell it with letters and digits plus the _ character, as long as the first character is not a digit. Upper and lower case count as different characters: total is one name, and Total and TOTAL are 2 more. A space ends a name, as does a hyphen or any other punctuation, which is why order total reads as 2 names and order-total reads as a subtraction.

The last 2 rows point at a short list of words with fixed meaning in the language. True, False, None, and, or, not, if, for, while, def, class, import, return are on it, and the list has a few more. Assigning to one of them stops the program before it starts, with a SyntaxError on that line.

Because Total and total are unrelated names, a typo in one place produces a name that was never assigned. Python reports that the moment the line runs, after any earlier lines have already produced their output.

print is a name too, attached at startup to the built-in object that writes to the screen. Nothing stops you from reattaching it to an integer. The assignment succeeds, and the very next call fails, because an integer can't be called.

Python only enforces the spelling rules above. The rest is convention, followed almost universally so that code reads the same across teams. Variable names are lowercase words joined by the _ character, which is called snake case. A value meant to stay fixed for the whole program is spelled in capitals, such as MAX_RETRIES = 3, a signal to readers rather than a lock. And a name says what the value is, so that a line can be read without scrolling up to the assignment.

In pipeline code the strongest names say where a value came from and what unit it is in. orders_raw_count and orders_clean_count can sit side by side without confusion, and timeout_seconds can't be mistaken for milliseconds. A name that took 5 extra characters to type saves the next reader a trip through the whole file.

A NameError quotes the exact spelling Python looked up and failed to find. Compare it character by character with the assignment that was meant to create it: a single capital letter makes a separate name. The misspelled assignment ran without complaint, so the error appears later, at the first line that reads the name.

A single = is a statement: it takes the object produced by the expression on its right and binds the name on its left to it. It produces no value of its own, which is why = can never sit inside a larger expression. A double == is an operator: it compares the objects on both sides and produces a bool, which is either True or False. That result is an ordinary value. You can print it or store it, and another operator can take it as input.

Read = aloud as "is set to" and == as "is equal to", and most mistakes disappear before they're typed. The run below changes actual twice and compares it after each change. Notice that the comparison on line 3 is evaluated once, when that line runs, and the stored check does not update when actual changes later.

Line 7 prints True even though actual is 4 by then, because check refers to the bool object built on line 3, and nothing has rebound it. Line 8 makes actual point at the very object expected points at, so the final comparison is True again.

== asks whether 2 objects represent the same value. Numbers compare by their numeric value, so an int can equal a float. True equals 1 as well, because a bool is an integer underneath. A string never equals a number, even when the digits match, because the text "10" and the integer 10 are different kinds of object, and == between them reports False rather than failing.

That fourth line is the one that bites in data work. A value read from a CSV column arrives as text, and comparing it with a number is legal and always False, so a check that looks correct passes nothing. The later lesson on type conversions shows how to turn the text into a number before comparing.

The left side of an assignment names a place to attach the object. A literal like 5 or an expression like score + 1 is not a place, so Python rejects the whole program before running a single line.

Because == produces a value, a comparison can be stored under a name and reused. Name the stored bool as a question so the later line reads naturally, and remember that it records the answer at the moment it was computed.

Before writing a line, decide what it is for: changing what a name points at, or producing an answer. Storing an answer uses = at the left with == on its right side. Rebinding a name uses a single = alone. == compares numeric value, so it answers True when an int meets a float that holds the same number.

Every operator looks at the type of the object on each side before it does anything. For +, 2 numbers add and 2 strings join. A number next to a string has no meaning, so Python stops with a TypeError instead of guessing. The table lists what each pairing produces.

Among numeric types, the result takes the wider type. An int beside a float produces a float, and / produces a float even when both sides are int and the division is exact. A bool behaves as the integer 1 or 0 inside arithmetic, which is occasionally handy and more often a sign that the wrong value reached the expression.

+ between 2 strings joins them, and * between a string and an int repeats it. Neither one does any numeric work: "3" + "4" produces the 2-character text "34", because both operands are text. A bool works as the repeat count too, since it is an int underneath.

The fifth line is empty: a string repeated 0 times is the empty string, and printing it still ends the line.

Python raises a TypeError when a string sits beside a number under +. It does the same for - or * between 2 strings, and for any / involving text. The program runs normally up to that line, prints whatever it printed, and stops. The message names both types, which tells you which operand carried the wrong kind of value.

print takes any number of values separated by commas, converts each one to text on its own, and writes them with a space between. That is the route for showing a number next to a label without an operator in between. Turning a number into a string yourself is covered in a later lesson on type conversions.

The comma route adds exactly 1 space between arguments, on top of any spaces inside the text. A label written for joining with + usually ends in a space, so drop it when you switch, or the output shows 2.

The second output line has 2 spaces between the colon and the 9: one from the label and one added by print. When a + line fails because one side is a number, replace it with a print call that passes the label and the value as separate arguments. Trim the label's trailing space in the same edit.

Each operator needs the pair it accepts. A repeat count stands on the other side of * from the string: "-" * 4 gives ----, while "-" * "4" fails. The same int added to a float gives a float, so 4 + 0.5 is 4.5.

When an expression holds several operators, Python applies them in a fixed order rather than left to right across the whole line. ** goes first. * and / share the next level with // and %. Below them sit + and -, and == comes last. Within one level, evaluation runs left to right, except for **, which runs right to left. Parentheses override all of it, and they're also the only way to tell a reader what you meant.

Line 3 is the surprising one: 2 ** 3 ** 2 is 2 ** 9, which is 512, while (2 ** 3) ** 2 would be 64. Line 4 is the other: the exponent binds tighter than the minus sign, so the result is the negative of 4. Both are legal, and both are the kind of line a colleague will misread, which is the reason to add parentheses even where Python does not need them.

Python ignores spaces inside an expression: a*b+c runs the same as a * b + c. The convention is 1 space on each side of = and ==. The lower-precedence operators get the same spacing, while a higher-precedence operator loses its spaces so the grouping shows: a*b + c. A line longer than about 80 characters gets split by naming part of it, as above.

A fixed fee plus a per-item cost needs no parentheses, because * runs before +: 5.0 + 4 * 1.5 multiplies to 6.0 first and sums to 11.0. Swap the 2 operators and 5.0 * 4 + 1.5 gives 21.5. Working the line through with real numbers shows whether each operator sits where it belongs.

String operators share the same precedence. In "-" * 3 + "x" the repetition runs first and produces ---. The join then gives ---x. Writing "x" + "-" * 3 gives x--- for the same reason: the * on the right finishes before the join begins.