Python Expressions: Intermediate

Every value in Python has exactly one type, and the operators act according to that type. 19 + 99 adds 2 numbers and gives 118, while "19" + "99" joins 2 strings and gives "1999". Text is how data arrives from a keyboard, a web form or a spreadsheet export, so a program that wants arithmetic has to convert first.

The first print repeats the text 4 times, because * on a string means repeat. After float() and int() turn the text into numbers, the same * multiplies. The product shows as 17.0 because any arithmetic that involves a float produces a float, even when the result is a whole number.

int() on a float never rounds. int(7.9) gives 7 and int(7.1) gives 7, because the conversion keeps the whole part and discards the rest. When you need the nearest whole number, that's a different operation, and this lesson leaves it alone: the point here is that int() only ever removes.

A conversion is a one way trip whenever the target type cannot hold everything the source held. int(7.9) throws away the .9, and converting back with float() gives 7.0. Text has the same problem in the other direction: a number has no leading zeros, so a US postal code that starts with 0 loses a digit the moment it becomes an int.

The code round trips as "2134", which a shipping label would reject. Postal codes, phone numbers and account identifiers are made of digits, but you never add or multiply them, so keep them as str. Convert to a number only when the value is about to be used as one.

int() reads a string as a whole number and refuses anything else, including a decimal point: int(reading) on this text stops with ValueError: invalid literal for int() with base 10: '42.5'. The fix takes 2 steps: int(float(reading)) parses the decimal first and then drops the fraction, giving the 42 on the last line. The ValueError quotes the exact text it rejected, so the traceback shows what the string really contained, which matters when the culprit is a stray space or a currency symbol you didn't know was there.

Writing "You have " + items without the conversion stops with TypeError: can only concatenate str (not "int") to str, because + needs both operands to be strings before it will concatenate. str(items) produces "3", which joins without complaint. print() with several arguments separated by commas converts each one for you, as line 3 shows, so it needs no str() call; the explicit conversion is for the moment you build one string to keep.

Each converter matches the shape of the text it reads: float() for text with a decimal point, int() for whole digits. Handing "12.5" to int() would stop with the ValueError from earlier, and once both values are numbers, a float times an int gives a float.

A comparison takes 2 values and produces a bool, which is either True or False. That result is a value like any other: you can print it, store it in a variable, or feed it into a larger expression. Later lessons use it to steer which lines run; this one makes sure you can predict the result before it drives anything.

enough holds False, and the variable name reads as the question it answers. Naming a comparison result this way pays off whenever the same condition would otherwise appear twice. == and != are exact opposites: for any pair of values, exactly one of them is True.

5 == 5.0 is True because Python compares the numeric value, and the int 5 and the float 5.0 stand for the same quantity. True == 1 is also True, since bool is a kind of int, with True worth 1 and False worth 0. A string of digits plays by other rules: "5" == 5 is False with no error, because a string and a number can never be equal, however alike they look when printed.

Python walks both strings from the left and decides at the first position where they differ. "apple" is less than "banana" because "a" comes before "b" at the first position. "apple" runs out before "apples" does, and a shorter string that matches so far counts as smaller. "10" < "9" is True because the first characters are "1" and "9", and the second character is never consulted. Every character has a numeric code, and uppercase letters have smaller codes than lowercase ones, which is why "Zebra" sorts before "apple".

Ordering a string against a number goes further than False: "10" < 9 raises TypeError: '<' not supported between instances of 'str' and 'int'. That ordering has no sensible answer, so Python stops instead of guessing. Equality behaves differently: "1" == 1 quietly gives False, because asking whether 2 things are the same is always answerable, and for different types the answer is no. Both outcomes point to one habit: convert the text with int() before comparing it to a number.

As text, "100" loses to "90" because "1" comes before "9". As numbers, 100 wins. Scores that were never converted will order 100 before 11 and before 2, and the bug shows up as results that look almost right, which is the hardest kind to notice. The conversion is one call per side, and it turns a question about characters into a question about quantities.

Testing 2 floats for exact equality has its own pitfalls, which a later lesson covers. Comparisons between ints, between strings, and between an int and a float are safe to reason about today.

Asking whether a shelf covers an order means asking whether the stock is at least the amount wanted, which is >=. When one side arrives as text, convert it first, because an ordering operator between a str and an int raises before it produces any answer.

A running total repeats one shape of statement: read the variable, change it, store it back under the same name. total = total + 5 says total twice. The augmented form total += 5 says it once and does the same work: it evaluates the right side, applies the operator to the current value, and binds the result to the name.

Follow balance line by line: 125, then 85, then 170. The /= step gives 42.5 and changes the type along the way, because / always produces a float even when the division is exact. count goes 3, then 1, then 1. Each shorthand follows the rule of its own operator, including the type of the result, so //= keeps an int and /= never does.

The right side can be any expression, and it's evaluated fully before the operator is applied. total += bonus * 2 doubles bonus first and then adds. Strings accept += too: label += "!" builds a new string with the exclamation mark on the end and binds label to it, since a string, once made, never changes.

This section introduces one new kind of value, far enough to show the difference. A list is a sequence of values in square brackets, ["apple", "pear"], and + between 2 lists builds a longer list. Lists get their own lessons later; here they stand in for every value that can be changed after it is made. Play the animation and watch what each name points at after every line.

alias_total = total makes a second name for the same 10. When total += 5 runs, Python has no way to change the number 10 itself: an int is immutable, so it creates a new 15 and points total at it, while alias_total still points at 10. The list behaves differently. cart += ["fig"] extends the existing list object in place, and alias_cart names that same object, so printing either shows 3 items. The last step, cart = cart + ["plum"], builds a brand new list, and only cart moves to it.

=+ 1 parses as = +1, a plain assignment of positive 1. Nothing is added, no error is raised, and retries becomes 1. The 2 characters in the wrong order are a frequent cause of counters that reset instead of counting, and because the program runs cleanly the mistake only shows in the numbers it reports.

A program with a =+ typo runs to the end and prints a wrong number, so the evidence sits in the output: a total equal to the last amount added means that line replaced the value instead of adding to it.

Line 3 is the swap. Python evaluates high, low to the values 20 and 10 while both names still hold their old values, then assigns 20 to low and 10 to high. Without this form, a swap needs a third variable to park one value while the other moves across.

width = height = 8 binds the value 8 to height and to width. Both names point at the same object, which costs nothing when the value is a number, because a number cannot change. It matters as soon as the value can.

a = b = [] creates 1 list and 2 names for it, so extending through a shows up through b, exactly as in the previous section. c, d = [], [] evaluates 2 separate [] expressions and creates 2 lists. Chained assignment suits numbers and strings, and lists only when you mean to share one; for anything changeable that should stay independent, give each name its own value.

Python checks the count before binding anything, so a mismatch leaves every name on the left as it was. The message states how many names were waiting and, for the shortfall case, how many values arrived. Read the number after expected as the count of names on the left side.

The paired form computes a + b with the old a, which is 3, giving 7. The separate statements update a first, so a + b becomes 4 + 4. Whenever a new value depends on an old value that is also being replaced, the single statement is the one that reads every old value.

A variable that exists but has nothing meaningful to hold yet needs a value that says so. Python provides exactly one: None. It has its own type, NoneType, and there is only ever 1 None object in a running program. Using 0 or an empty string for missing data confuses the absence of a value with a real value that happens to be 0 or empty.

refund is None: no refund has been recorded. amount is 0: a refund of zero dollars was recorded. Those are 2 different facts, and the last line shows the test that tells them apart. is None asks whether the variable points at the one None object; == 0 asks whether the value is numerically zero.

Every object in a program has an identity, a number that stays fixed for the object's lifetime, and id() returns it. a is b is True exactly when id(a) == id(b): the 2 names refer to one object. a == b asks a looser question, whether the 2 values count as equal, and 2 separate objects can answer yes.

a and b are 2 lists built separately with the same contents: equal, and separate. c = a adds a name to the first list, so a is c holds. This is the aliasing picture from the augmented assignment section, now with the operator that tests for it directly.

refund == None also prints True, so why does Python's style guide ask for is None? Because None is a single object, identity is the precise question, and is cannot be redefined. A type may define its own meaning for ==, and some do, which can make == None return something other than a plain True or False. is has no such escape hatch. The reverse applies to numbers and strings: they can be equal while living in separate objects, so is between them gives answers that depend on how the interpreter chose to store them.

print() displays its arguments and then hands back None, because it has nothing else to give. Storing that result and treating it as text leads to a TypeError one line later. Any time a variable unexpectedly prints as None, the first suspect is a call whose result was stored when only its screen output was wanted.

The fix for a stored print() result is to keep its 2 jobs apart: put the text in the variable, then pass the variable to print() at the moment it should appear on screen.