Chapter 3 — Your First Python Program

The why

Every programming journey starts with one step: writing code that does something visible. In Python, that's print("Hello, world!"). It's a cliché for a reason — it proves your setup works, and it gives you a feedback loop: write code, run it, see what happens.

This chapter teaches you two ways to run Python — script files and the REPL — and how to read the output (and the errors). By the end, you'll be able to write, run, and debug simple programs.

Core concepts: Python execution models

Before diving into code, understand how Python runs your programs:

Two ways to run Python

1. Script files — You write code in a .py file and run it with python filename.py. The interpreter reads the file from top to bottom, executes each line, and exits.

2. The REPL — You type code interactively in the terminal, and Python executes each line immediately. The REPL is great for experimenting; script files are for programs you want to save and reuse.

When to use each:

• REPL: Quick experiments, testing a function, debugging a small piece of code
• Script file: Anything you want to save, share, or run again later

Your first script

Create a file called hello.py:

# hello.py
print("Hello, world!")

Run it from the terminal:

$ python hello.py
Hello, world!

That's it. You just wrote and ran your first Python program.

What happened:

1. Python opened hello.py
2. It read the code line by line
3. It executed print("Hello, world!"), which outputs the text to the terminal
4. It reached the end of the file and exited

print() — more than you think

The print() function outputs text to the terminal. But it's more flexible than most beginners realize.

Basic usage:

print("Hello, world!")
# Hello, world!

Multiple arguments:

print("Name:", "Alice", "Age:", 30)
# Name: Alice Age: 30

By default, print() separates arguments with a space. You can change this with the sep parameter:

print("2024", "01", "15", sep="-")
# 2024-01-15

The end parameter:

By default, print() adds a newline at the end. You can change this:

print("Hello", end=" ")
print("world!")
# Hello world!

f-strings (a preview):

f-strings let you embed variables directly in strings. We'll cover them in depth in Chapter 5, but here's a taste:

name = "Alice"
age = 30
print(f"Name: {name}, Age: {age}")
# Name: Alice, Age: 30

The f before the string means "formatted string". The {name} and {age} are replaced with the variable values.

The REPL: your interactive scratchpad

Open the REPL by running python (Windows) or python3 (macOS/Linux) in the terminal. You'll see a >>> prompt.

>>> 2 + 2
4
>>> print("Hello")
Hello
>>> name = "Alice"
>>> print(f"Hello, {name}!")
Hello, Alice!
>>> exit()

Key behaviors:

• Expressions are evaluated and printed automatically. 2 + 2 outputs 4 without needing print().
• Statements (like assignments) don't print anything. name = "Alice" doesn't output anything — it just creates the variable.
• The REPL remembers variables. After name = "Alice", you can use name in later commands.

When to use the REPL:

• Testing a small piece of code
• Debugging a function
• Exploring a library's API
• Quick math (yes, people use Python as a calculator)

When NOT to use the REPL:

• Anything longer than 10 lines — use a script file
• Code you want to save or share
• Programs with loops and conditionals (they're awkward in the REPL)

Comments: notes for humans

Comments are text in your code that Python ignores. They're for humans — explanations, reminders, or notes to future-you.

Single-line comments start with #:

# This is a comment
print("Hello")  # This is an inline comment

Multi-line comments use """ or ''' (triple quotes). These are technically string literals, but they're commonly used as multi-line comments:

"""
This is a multi-line comment.
It spans several lines.
Python ignores it.
"""
print("Hello")

Docstrings are a special kind of multi-line comment that documents functions, classes, or modules. We'll cover them in Chapter 8.

When to comment:

• Explain why you did something, not what you did (the code should be self-explanatory)
• Mark TODOs or FIXMEs
• Explain non-obvious logic

When NOT to comment:

• Don't comment obvious code: x = 5 # Set x to 5 is useless
• Don't comment out large blocks of code — delete it or use version control
• Don't write essays — if you need a paragraph, write a README

Reading tracebacks: your first error

Errors are inevitable. The good news: Python's error messages (called tracebacks) are detailed and helpful. The bad news: they look scary at first.

Let's break one down. Create a file with a bug:

# bug.py
print("Hello")
print(x)  # x is not defined
print("World")

Run it:

$ python bug.py
Hello
Traceback (most recent call last):
  File "bug.py", line 2, in <module>
    print(x)
          ^
NameError: name 'x' is not defined

How to read a traceback (bottom-up):

1. Start at the bottom. The last line tells you the error type and message: NameError: name 'x' is not defined.
2. Read the file and line number. File "bug.py", line 2 tells you the error is on line 2 of bug.py.
3. Look at the code snippet. print(x) shows the line that caused the error. The ^ points to the problematic part.
4. Work upward if needed. If the error happened inside a function, the traceback shows the call stack — which function called which. For now, just focus on the bottom.

Common error types you'll see:

Real-world usage

Scripting: System administrators use Python scripts to automate tasks. A simple backup script might look like:

# backup.py
import shutil
import datetime
 
today = datetime.date.today()
backup_name = f"backup_{today}.zip"
shutil.make_archive(backup_name, "zip", "/path/to/data")
print(f"Backup created: 

Data processing: Data scientists use scripts to process CSV files:

# process.py
import csv
 
with open("data.csv") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(f"Name: {row['name']}, Age: 

Web scraping: Developers use Python to extract data from websites (with the requests and BeautifulSoup libraries).

Common mistakes

Production notes

Logging vs print: In production code, use the logging module instead of print(). Logging lets you control output levels (DEBUG, INFO, WARNING, ERROR) and write to files. We'll cover it in L5.

Encoding: Python 3 uses UTF-8 by default, so you can print Unicode characters (emojis, accented letters, etc.) without issues. If you see UnicodeEncodeError, check your terminal's encoding settings.

Shebang lines: On macOS/Linux, you can make a Python script executable by adding a shebang line at the top:

#!/usr/bin/env python3
print("Hello")

Then run chmod +x script.py and execute it with ./script.py. This is optional — you can always run it with python3 script.py.

Practice: Prove your Mastery

Interview Questions

Summary

• Run Python two ways: script files (python file.py) for saved programs, REPL for experiments.
• print() outputs text. Use sep to change separators, end to change the line ending, and f-strings for formatting.
• Comments (#) are for humans. Explain why, not what.
• Read tracebacks bottom-up: error type → file/line → code snippet.
• Common errors: NameError (undefined variable), SyntaxError (invalid syntax), IndentationError (bad indentation).

Quick recall

I want to…
├── Run a script → python file.py
├── Open the REPL → python (or python3)
├── Print text → print("Hello")
├── Format output → print(f"Name: {name}")
├── Add a comment → # This is a comment
└── Read an error → Start at the bottom of the traceback

Self-Check Quiz