Python Foundations: Intermediate

if runs its block only when the expression after it is True. Here price > balance is True, so both indented prints run, and then line 6 runs because it was never inside the block. Swap the numbers so the condition is False and the indented lines are skipped, while line 6 still runs. Now watch what one change in spacing does to the same 6 lines.

Each header gets a lesson of its own later. What matters here is the shape they share: a colon, then an indented block, then a return to the left margin. Press play on the loop below and watch the single indented line run 5 times while the header hands i a new value on each pass.

A def block differs in timing. When the file runs past line 1, Python stores the 2 indented lines under the name calculate_total and runs none of them. They run on line 5, when the name is called with 100 and 0.08, and the result 108.0 travels back to be stored in result and printed.

A block can hold another header, which opens a deeper block one level further in. Each level is, by convention, 4 more spaces; Python requires only that every line of one block is indented the same amount. In the program below, ask of every line which header owns it. Lines 4 and 5 sit 8 spaces in, so they belong to the if, which itself belongs to the for. Line 6 sits 4 spaces in, belongs to the for alone and runs on every pass. Line 7 is back at the margin and runs once, after the loop has finished all 4 passes.

Python ships with hundreds of modules, each a file of code written and tested for you: square roots, random numbers, dates, text in JSON form. Python loads a module only when you ask for it. The import statement finds the module's file, runs it once, and binds the module's name in your program so you can reach what it holds with a dot.

Read math.sqrt as the sqrt that lives inside math. After line 1 the name math refers to the module, and the dot looks inside it for a name. sqrt returns a float even for a perfect square, pi is a plain float with 15 digits after the point, and floor drops the fraction and hands back an int. Leave out line 1 and the name math means nothing to the program.

import math brings in the whole module under one name, and every use carries the prefix. from math import sqrt, pi copies those 2 names into your program, so you call sqrt(81) with no prefix. The second form reads shorter, at the cost of hiding where sqrt came from when someone reads line 40 of your file.

Each of these is installed with Python itself, so import json works on any machine that has Python and nothing else. Naming a module that does not exist, or misspelling one, fails at the import line with a ModuleNotFoundError rather than somewhere later in the program.

A module is any file ending in .py, including the ones you write. Save the constants and helpers that 2 scripts share in a file named pricing.py, and both scripts can import pricing. The module's name is the filename without .py, and Python looks for it first in the folder the running script lives in.

Importing pricing runs every line of pricing.py once, top to bottom, which is how TAX_RATE gets its value and with_tax gets defined. A print at the top level of pricing.py would run at import time too, which surprises people the first time a bare import produces output. Keep a module's top level to constants and definitions, and the importing script decides what gets printed.

Every program so far had its values written into the code. input() lets the person running the program supply a value while it runs. The call shows its prompt text, pauses, waits for the user to type and press Enter, and then hands back whatever was typed. The program resumes on the next line with that text stored wherever you assigned it.

The prompt is ordinary text, so end it with a space or the cursor sits jammed against the colon. Whatever comes back is a string, every time. Type 42 and input returns "42", 2 characters that happen to be digits. Press Enter with nothing typed and it returns "", the empty string. Spaces typed before or after the value survive as well.

Treating that string as a number is the most frequent mistake in a first program with input. The program below stands in for a session where the user typed 30 at an Age prompt; the variable holds exactly what input would have returned, so the result is the same as the live version.

Python refuses because + between a string and an int has no single meaning: join them, or add them? The message says which reading it took, concatenation, and what it could not accept, the int. Before any arithmetic, convert the text to a number with int() or float(). Each is a function that reads a string of digits and returns the matching numeric value.

int() accepts digits with an optional leading sign and ignores spaces around them, so int(" 7 ") returns 7. float() accepts those plus a decimal point, so float("3") returns 3.0. Text that isn't a number, such as letters or, for int(), a decimal point, makes the conversion fail with a ValueError, the signal that the type was right and the content was wrong.

The first 2 lines printed before line 3 failed, because a program runs every line up to the one that raises. int("3.5") fails the same way, since a decimal point is not a digit; convert through float() when the user may type a fraction.

The usual shape wraps the input call directly in the conversion, so the variable never holds the raw string and no later line can forget to convert it.

The fourth row shows the program dying at line 1, so the Quantity prompt never appears. The last row shows that int() rejects a fraction even though a human would read 1.5 as a number. Checking the text before converting, and asking again when it fails, uses tools from a later lesson; for now the rule is that the conversion line is where bad input surfaces.

When the failing line sits inside a def block, the traceback shows 2 frames: the call that started things, then the line inside the function that raised. Most recent call last means the frame at the bottom is the one that was running when the error happened.

The bottom frame says line 2 divided by zero. The frame above explains why count was 0: line 4 passed it in. The fix belongs at line 4, or at whatever produced the 0, rather than at line 2, which did exactly what it was written to do. A traceback marks where the error surfaced; the cause can be any line that ran earlier.

Running python with a filename executes a script: Python reads the file, runs it top to bottom, and exits. Running python with no filename opens the interactive shell. It shows a >>> prompt, runs each line the moment you press Enter, and waits for the next one. Everything in this lesson works in both, with one difference that changes how each is used.

The shell prints the value of any expression you type, with no print call, and shows a string with quotes around it so that '40' and 40 can be told apart. A script does none of that. Put the same lines in a file and run it, and only the print line produces output.

Lines 1, 3 and 4 were computed and their results thrown away. In a script, output comes from print alone; in the shell, output also comes from the expression echo. A value you saw in the shell goes silent in a script until you wrap it in print.

A header line in the shell switches the prompt to ..., meaning a block is open. Type the indented lines, then press Enter on an empty line to close the block and run it. That blank line is what the shell needs, unlike a script, where dedenting alone closes a block.

In the last row, i still holds its final value after the loop, because the shell remembers every name you assign until you close it. Close the shell with exit() or Ctrl-D and all of it is gone, which is why anything worth keeping goes in a file.

The 2 work together. Try an expression in the shell until it gives the value you want, paste that line into the script, and run the script. When a traceback points at a line, type that line into the shell with the same values to watch the failure up close. dir(math) and help(math.floor) answer most questions about a module faster than a search does.