First Steps

What is a program?

A program is a precise list of instructions for a computer. "Precise" is the key word. A human reading a recipe that says "add a pinch of salt" fills in the gaps. A computer cannot fill gaps: it does exactly what the instructions say, nothing more and nothing less. Programming is the craft of writing instructions so clear that a machine with no common sense can follow them.

Instructions are written in a programming language, a language with strict rules of grammar (called syntax) and meaning (called semantics). Python is a programming language designed to be readable: Python code often looks almost like English.

temperature = 31
if temperature > 30:
    print("It's hot. Drink water!")

Even before learning any rules you can probably guess what this does. That readability is not an accident; it is Python's central design goal, and it is a big reason Python is used for everything from scientific research to websites to machine learning.

The text of a program is called source code (or just "code"). Python source code is stored in plain text files ending in .py.

Remember: a program is an exact list of instructions; syntax is the grammar, semantics is the meaning; source code is the text you write.

How Python runs your code

Your CPU (the computer's processor) does not understand Python. It understands only machine code, very low-level numeric instructions. Something has to bridge the gap. For Python that something is the interpreter: a program that reads your Python code and carries out its instructions. The standard interpreter, the one Pixi installs, is called CPython because it is written in the C language.

CPython works in two stages:

flowchart LR
  A["Source code
hello.py"] -->|"compile"| B["Bytecode
(instructions for the PVM)"]
  B -->|"execute"| C["Python Virtual Machine
(the evaluation loop)"]
  C --> D["Output, files,
network..."]
    

1. Compile to bytecode. CPython first checks your code's syntax and translates it into bytecode: a compact list of simple instructions such as "load this name", "multiply", "store the result". If there is a SyntaxError this stage fails and nothing runs.
2. Execute on the PVM. The Python Virtual Machine (PVM) is a loop inside CPython that executes bytecode instructions one after another. It is "virtual" because it is a machine made of software rather than hardware.

You can peek at the bytecode with the standard-library dis module ("disassembler"). Do not try to memorize it; just notice that one line of Python becomes a few tiny steps.

Reading the output: LOAD_NAME price fetches the value named price, LOAD_SMALL_INT 2 pushes the number 2, BINARY_OP (*) multiplies them, and STORE_NAME total saves the result under the name total. The PVM keeps intermediate values on a stack, a pile where the last thing put on is the first taken off.

Remember: CPython compiles source to bytecode, then the PVM executes the bytecode. Syntax errors stop the first stage, so they prevent the whole file from running.

The REPL vs scripts

You met both in M00. Here is when to use each.

The biggest beginner surprise: in the REPL, typing 2 + 2 displays 4. In a script, the same line computes 4 and then silently throws it away. If you want to see it, you must print it.

>>> 2 + 2        # REPL: the value is echoed
4
>>> "hi".upper()
'HI'

The browser cells in this course behave like scripts. Predict what this cell shows:

Remember: the REPL echoes expression values; scripts only show what you print.

Talking to the world with print

print is a function: a named, reusable piece of code that you call by writing its name followed by parentheses. Values inside the parentheses are arguments, the inputs you hand to the function. print writes its arguments to the screen (more precisely, to standard output, the program's main text output stream).

print("Hello")            # one argument: a string
print("Answer:", 42)      # two arguments, separated by a comma
print()                   # no arguments: prints an empty line

A string is a piece of text in quotes. Single ('hi') and double ("hi") quotes mean the same thing.

sep and end

When you give print several arguments it puts a separator between them (a space by default) and finishes with an end string (a newline by default, written "\n"). You can change both with keyword arguments: arguments passed by name, as in sep="-".

Remember: print(a, b, sep=" ", end="\n"); arguments are separated by sep and followed by end.

Comments, expressions, and statements

Comments

A comment starts with # and runs to the end of the line. Python ignores it completely; it is a note for humans, including future you.

# Convert minutes to hours for the timesheet report.
minutes = 135
hours = minutes / 60  # 2.25

Good comments explain why, not what. x = x + 1 # add one to x wastes the reader's time; retries = retries + 1 # the API sometimes fails on the first call tells them something the code cannot.

Expressions

An expression is a piece of code that produces a value. 42, "hi", 3 * 7, minutes / 60, and len("Pixi") are all expressions. You can combine expressions into bigger ones, like LEGO bricks.

Statements

A statement is a complete instruction that does something. An assignment statement such as hours = minutes / 60 evaluates the expression on the right and gives the result a name (also called a variable) on the left. if, for, and import are statements too. A statement does not itself have a value: you cannot write print(x = 5) and expect the assignment to happen.

Step through this program with the tracer. Watch each statement run in order and each name appear with its value.

Remember: expressions produce values; statements perform actions; assignment binds a name to the value of an expression.

Indentation is part of the grammar

Many languages use braces { } to group lines into a block (a group of statements that belong together). Python uses indentation, the spaces at the start of a line. A line ending with a colon : introduces a block, and every line of the block is indented by the same amount. The standard is four spaces.

score = 87
if score >= 50:
    print("You passed!")       # inside the if block
    print("Well done.")        # still inside
print("Thanks for playing.")   # back outside: always runs

Because indentation carries meaning, code that is visually tidy is also code that is correct. The flip side is that inconsistent indentation is an error:

  File "app.py", line 3
    print(x)
    ^^^^^
IndentationError: expected an indented block after 'if' statement on line 2

Remember: a colon opens a block; the block is the indented lines below it; use four spaces.

Reading tracebacks like a detective

Errors come in two families. Syntax errors are found while compiling, before any code runs. Runtime errors, called exceptions, happen while the program is running, when an instruction turns out to be impossible. Here is a runtime error:

Traceback (most recent call last):
  File "receipt.py", line 2, in <module>
    print("Total: " + 5)
          ~~~~~~~~~~^~~
TypeError: can only concatenate str (not "int") to str

Detective method:

1. Last line: what happened. A TypeError: the types (kinds) of value do not fit. You cannot glue (concatenate) a string and an integer with +.
2. Above it: where. File receipt.py, line 2. The tildes and caret point at the +.
3. Form a hypothesis and test it. "I need to turn 5 into text": "Total: " + str(5), or just print("Total:", 5).

Python 3.14 is exceptionally helpful with suggestions. Run each line separately (comment the others out with #) and read the hints:

Remember: syntax errors stop everything; exceptions stop at the failing line; the last line of a traceback says what, the lines above say where.

Exploring with type(), dir(), and help()

Everything you work with in Python is an object: a value in memory that has a type (what kind of thing it is) and operations it supports. Three built-in functions let you explore any object, and you will use them for the rest of your career:

• type(x) tells you what kind of object x is.
• dir(x) lists the names (attributes and methods, functions that belong to an object) available on x.
• help(x) shows its documentation.

Names beginning with underscores (like __len__) are special internal names; filtering them out keeps the list readable. You will learn what they do in the module on the data model.

Remember: type answers "what is it?", dir answers "what can it do?", help answers "how do I use it?".

Style: PEP 8 and the Zen of Python

Code is read far more often than it is written. Python's community agreed on a style guide called PEP 8 (a PEP, "Python Enhancement Proposal", is a design document for Python). Its core rules:

• Indent with four spaces.
• Names of variables and functions use lower_case_with_underscores ("snake case").
• Put spaces around operators and after commas: total = price * 2, print(a, b).
• Keep lines reasonably short (PEP 8 says 79 characters; many teams, including this course, use up to 120).
• Use blank lines to separate logical sections.

X=10;Y=20
TOTALPRICE=X*Y
print( TOTALPRICE )

quantity = 10
unit_price = 20
total_price = quantity * unit_price
print(total_price)

Python also has a philosophy, written as a poem by Tim Peters and hidden as an "Easter egg" in the language:

Lines like "Readability counts", "Explicit is better than implicit", and "Errors should never pass silently" will come up again and again in this course. They are good guides when you have to choose between two ways of writing something.

Practice

print(2026, 10, 14, sep="-")

print("Ready, set,", end=" ")
print("go!")

item = "coffee"
price = 4
print("Item: " + item)
print("Price:", price)

seconds_in_week = 60 * 60 * 24 * 7
print(seconds_in_week)

+--------+
| Python |
+--------+

border = "+" + "-" * 8 + "+"
print(border)
print("| Python |")
print(border)

Mini-project: a personal greeting card

Quiz

Recap

• A program is a precise list of instructions written in a language with strict syntax.
• CPython compiles source code to bytecode, which the Python Virtual Machine executes.
• The REPL echoes values and is for exploring; scripts print explicitly and are for keeping.
• print takes any number of arguments plus sep and end.
• Comments explain why; expressions produce values; statements perform actions.
• Indentation defines blocks; use four spaces.
• Read tracebacks bottom-up; use type, dir, and help to explore.
• Follow PEP 8 and let tools like ruff format for you.

Going further

• An informal introduction to Python (official tutorial)
• print in the built-in functions reference
• The dis module
• PEP 8, the style guide and PEP 20, the Zen of Python
• Errors and exceptions (official tutorial)
• Next: M02 · Values, Types & Variables