Python Fundamentals

1.1 What is Python?

Python is a programming language. You can use it to write small scripts, automation tools, web applications, and many other types of software.

Python is popular because its code is easy to read and quick to write.

print("Hello, Python!")

When you run this program, Python displays:

Hello, Python!

A Python program is usually saved in a file ending with .py. You can run the file with the Python interpreter:

python3 hello.py

1.2 A Short History

Python was created by Guido van Rossum. The first public version was released in 1991.

The language was designed with a simple goal: developers should be able to write clear and useful programs without unnecessary complexity.

Python 3 is the current version. Python 2 reached the end of its life on January 1, 2020, so new projects should use Python 3.

# Python 3
print("Use Python 3 for new projects")

1.3 Main Features of Python

1. Easy to read syntax
2. Cross platform
3. Large standard library
4. Many third-party packages
5. Dynamically typed

1. Easy-to-Read Syntax

Python code often looks close to plain English. It uses indentation to show which lines belong together.

name = "Alex"

if name:
    print(f"Hello, {name}")

2. Cross-Platform

Python is available on Linux, Windows, and macOS. The same script can often run on all three operating systems.

3. Large Standard Library

Python includes useful modules for files, JSON, dates, networking, and many other common tasks. You can use these modules without installing extra packages.

import json

server = {"name": "web-01", "status": "running"}
print(json.dumps(server))

4. Many Third-Party Packages

When the standard library is not enough, you can install packages from PyPI. Examples include:

• boto3 for AWS
• requests for HTTP APIs
• pytest for testing
• pandas for data analysis

5. Dynamically Typed

You do not have to declare a variable type before using it. Python works out the type from the value.

count = 5
name = "web-server"

print(type(count))
print(type(name))

1.4 Why Learn Python?

Python is useful because it helps you solve real problems with a small amount of code.

• Automation: Automate repetitive tasks such as moving files, creating reports, and checking servers.
• DevOps: Write scripts for CI/CD, monitoring, deployments, and infrastructure management.
• Cloud: Use cloud SDKs such as boto3 to manage AWS resources.
• Web development: Build websites and APIs with frameworks such as Django, Flask, and FastAPI.
• Data and AI: Work with data and machine learning using libraries such as pandas, NumPy, and PyTorch.

1.5 Where Is Python Used?

Python is commonly used for:

1. Web development: Building websites and APIs.
2. Automation: Replacing repetitive manual work with scripts.
3. Data science: Cleaning, analyzing, and visualizing data.
4. Machine learning: Building and using machine-learning models.
5. Networking: Creating API clients, monitoring tools, and network scripts.
6. Cybersecurity: Analyzing logs and automating security checks.

1.6 Why Python Is Useful for DevOps

DevOps engineers work with servers, cloud services, APIs, containers, and CI/CD pipelines. Python can connect these systems and automate work between them.

Infrastructure Automation

Python can connect to servers and run administrative tasks. Libraries such as paramiko can be used for SSH automation.

import paramiko

client = paramiko.SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect('server01', username='deploy', key_filename='id_rsa')
stdin, stdout, stderr = client.exec_command('uptime')
print(stdout.read().decode())

AWS Automation

boto3 is the AWS SDK for Python. It allows Python programs to work with AWS services such as EC2, S3, Lambda, and IAM.

import boto3

ec2 = boto3.client('ec2')
response = ec2.describe_instances()
# The response contains information about EC2 instances.

CI/CD

Python scripts can run tests, build packages, check deployments, and trigger other tools inside Jenkins, GitHub Actions, or GitLab CI.

Monitoring

Python can check application health, read metrics, process logs, and send alerts.

Configuration Management

Ansible is built with Python. Python knowledge is useful when creating custom Ansible modules or automation scripts.

1.7 Python Compared with Other Tools

Python and Bash

Bash is excellent for short commands and simple Linux tasks. Python is usually better when a script needs data structures, reusable functions, API calls, or detailed error handling.

Python and Go

Go is compiled and is a good choice for fast, standalone tools. Python is often quicker to write and is popular for internal automation.

Python and PowerShell

PowerShell is a strong choice for Windows and Microsoft administration. Python is a good choice when the same automation must run across Linux, Windows, and macOS.

When to Choose Each?

Quick Interview Answer

Python is a general-purpose programming language created by Guido van Rossum and first released in 1991. It is popular because its syntax is easy to read and it helps developers write useful programs quickly. Python is widely used for automation, DevOps, cloud engineering, web development, data science, and machine learning.

Key Takeaways

• Python is a readable, general-purpose programming language.
• Python 3 should be used for new projects.
• Python works on Linux, Windows, and macOS.
• Python is useful for automation, cloud, DevOps, web development, and data work.
• Python can be extended with packages from PyPI.

Common Mistakes

• Assuming Python is only used for data science or machine learning.
• Using Python 2 for a new project. Python 2 is no longer supported.
• Choosing Python for every task. Bash, Go, or PowerShell may be a better fit in some situations.

Chapter practice checkpoint

Run python --version (or python3 --version on systems using that command). Save print("Hello, automation!") in hello.py, then run it from the terminal with python hello.py.

Expected output: Hello, automation! on its own line.

Knowledge check: What is the difference between the interpreter prompt and a saved script?

You are ready to continue when you can locate your script, run it, change its message, and explain the output.

1.1 What Do You Need?

To start writing Python, you need:

1. Python 3 installed on your computer.
2. A terminal to run commands.
3. A text editor such as VS Code.

You can download Python from python.org.

1.2 Install Python on Windows

1. Open python.org/downloads.
2. Download the latest Python 3 installer for Windows.
3. Start the installer.
4. Select Add python.exe to PATH.
5. Select Install Now.

The PATH option allows you to run Python by typing python in a terminal.

Open PowerShell and check the installation:

python --version

You can also use the Windows Python launcher:

py --version

1.3 Install Python on Ubuntu or Debian

Open a terminal and run:

sudo apt update
sudo apt install python3 python3-pip python3-venv

Check the installation:

python3 --version
pip3 --version

1.4 Install Python on Fedora, RHEL, or CentOS

Run:

sudo dnf install python3 python3-pip

Then check the installation:

python3 --version

1.5 Install Python on macOS

Homebrew is a common way to install Python on macOS. If Homebrew is already installed, run:

brew install python

Check the installation:

python3 --version
pip3 --version

1.6 Verify That Python Works

Run a small Python command:

python3 -c "print('Python is working')"

On Windows, use python or py if python3 is not available:

python -c "print('Python is working')"

You should see:

Python is working

1.7 Write Your First Python File

Create a file named hello.py:

print("Hello, Python!")

Run it from the terminal:

python3 hello.py

On Windows, use:

python hello.py

The output should be:

Hello, Python!

1.8 Choose an Editor

You can write Python in any text editor, but these tools make learning easier:

• VS Code: A lightweight editor with Python support, debugging, and extensions.
• PyCharm: A full Python development environment.
• IDLE: A simple editor included with many Python installations.
• Jupyter Notebook: Useful for learning, experiments, and data analysis.

For this course, VS Code with the official Python extension is a good choice.

1.9 Create a Virtual Environment

A virtual environment keeps the packages for one project separate from other projects.

Create one inside your project folder:

python3 -m venv .venv

Activate it on Linux or macOS:

source .venv/bin/activate

Activate it on Windows PowerShell:

.venv\Scripts\Activate.ps1

After activation, your terminal usually shows (.venv). You can now install packages without affecting other projects.

To leave the virtual environment, run:

deactivate

1.10 Install a Python Package

pip is Python’s package installer. For example, install the requests package inside an activated virtual environment:

python -m pip install requests

Check that it works:

python -c "import requests; print(requests.__version__)"

Using python -m pip makes sure that pip belongs to the Python interpreter you are using.

1.11 What Happens When You Run Python?

When you run a Python file, Python reads the file and executes the instructions.

For now, you only need to remember this:

• You write Python code in a .py file.
• The Python interpreter runs the file.
• Python displays the result or an error message.

Python may create a __pycache__ folder while it runs. This folder contains temporary cached files. You normally do not need to edit it.

1.12 Basic Python Style

Python uses indentation to group code. Use four spaces for each indentation level.

name = "Alex"

if name:
  print(f"Hello, {name}")

Use clear names:

server_count = 3

Avoid unclear names:

x = 3

Python’s common style guide is called PEP 8. It helps teams write code that looks consistent and is easy to read.

1.13 Common Installation Problems

Python Command Not Found

This usually means Python is not installed or its directory is not in the PATH.

On Windows, reinstall Python and select Add python.exe to PATH. Then close and reopen PowerShell.

On Linux or macOS, try python3 instead of python.

The Wrong Python Version Appears

Several Python versions can exist on one computer. Check the version before installing packages or running a project:

python3 --version

On Windows:

py --list

pip Installs into the Wrong Python

Use this form instead of calling pip by itself:

python -m pip install package-name

PowerShell Does Not Allow Virtual Environment Activation

If PowerShell blocks the activation script, use Command Prompt, or ask an administrator to review the PowerShell execution policy for your machine. Do not change security settings without understanding your organization’s policy.

1.14 Practice Exercise

1. Install Python 3.
2. Confirm the Python version.
3. Create a file named system_check.py.
4. Add this code:

import platform

print(f"Operating system: {platform.system()}")
print(f"Python version: {platform.python_version()}")

5. Run the file from your terminal.

Interview Questions

• How do you check whether Python is installed?
• What is the difference between python, python3, and py?
• What is PATH, and why is it important?
• What is a virtual environment?
• Why should you use python -m pip?
• How do you run a Python file from the terminal?

Quick Interview Answer

To install Python, I install Python 3 from the official Python website or the operating system package manager. I verify it with python --version or python3 --version, create a virtual environment for each project, and install packages with python -m pip. On Windows, I make sure that Python is added to PATH during installation.

Key Takeaways

• Install Python 3, not Python 2.
• Always verify the installation from a terminal.
• Use a virtual environment for each project.
• Use python -m pip to install packages for the correct interpreter.
• Use VS Code or another editor to write Python files.

Chapter practice checkpoint

Run python --version (or python3 --version on systems using that command). Save print("Hello, automation!") in hello.py, then run it from the terminal with python hello.py.

Expected output: Hello, automation! on its own line.

Knowledge check: What is the difference between the interpreter prompt and a saved script?

You are ready to continue when you can locate your script, run it, change its message, and explain the output.

1.1 Create Your First Python File

Open VS Code, IDLE, PyCharm, or another text editor. Create a file named hello.py and add this code:

print("Hello, World!")

Save the file. The .py ending tells your editor that the file contains Python code.

1.2 Understand the Program

The line contains two parts:

• print() is a Python function that displays text.
• "Hello, World!" is the text we want to display.

The output is:

Hello, World!

Python does not require a semicolon at the end of this line.

1.3 Run the Program on Windows

1. Open PowerShell or Command Prompt.
2. Move to the folder where you saved hello.py.

cd C:\Users\yourname\projects

3. Run the program:

python hello.py

You can also use the Windows Python launcher:

py hello.py

The output should be:

Hello, World!

1.4 Run the Program on macOS or Linux

1. Open a terminal.
2. Move to the folder where you saved hello.py.

cd ~/projects

3. Run the program:

python3 hello.py

On macOS and Linux, python3 is usually the correct command for Python 3.

1.5 Run the Program in VS Code

1. Open the hello.py file in VS Code.
2. Select the Python interpreter if VS Code asks you to choose one.
3. Click the Run Python File button in the top-right corner.

VS Code runs the file and shows the output in the terminal panel.

You can also right-click inside the file and select Run Python File in Terminal.

1.6 Run a Python Command Without Creating a File

You can use the -c option to run a short command directly.

On Windows:

python -c "print(2 + 2)"

On macOS or Linux:

python3 -c "print(2 + 2)"

The output is:

4

This is useful for quick checks, but larger programs should be saved in .py files.

1.7 Use the Python Interactive Shell

Run python on Windows or python3 on macOS/Linux without a file name:

>>> 2 + 3
5
>>> print("Testing Python")
Testing Python
>>> exit()

The interactive shell runs one line at a time. It is useful for testing small ideas.

1.8 Run a Script Directly on Linux or macOS

You can run a script directly by adding a shebang as the first line:

#!/usr/bin/env python3

print("Hello, World!")

Make the file executable:

chmod +x hello.py

Run it:

./hello.py

On Windows, run the file with python hello.py or py hello.py instead.

1.9 Add Variables and User Input

Now create a slightly more useful program:

name = input("What is your name? ")
print(f"Hello, {name}!")

When you run the program, Python waits for you to type a name and press Enter.

Example:

What is your name? Alex
Hello, Alex!

1.10 Common Mistakes

Running from the Wrong Folder

If Python cannot find the file, move to the correct folder with cd or provide the full file path.

can't open file 'hello.py': No such file or directory

Using Different Quote Characters

The opening and closing quotes must match:

print("Hello")

This is incorrect:

print("Hello')

Saving the Wrong File Name

Make sure the file is saved as hello.py, not hello.py.txt. On Windows, enable File name extensions in File Explorer if you cannot see the full file name.

Using the Wrong Python Command

Use the command that matches your operating system:

Forgetting to Save the File

Save the file before running it. Otherwise, Python may run an older version of your code.

1.11 Practice Exercise

Create a file named system_check.py:

import platform

name = input("Enter your name: ")
print(f"Hello, {name}!")
print(f"Operating system: {platform.system()}")
print(f"Python version: {platform.python_version()}")

Run the program and record the output.

Interview Questions

• How do you create a Python program?
• How do you run a Python file on Windows?
• How do you run a Python file on Linux or macOS?
• What is the difference between python, python3, and py?
• What does the print() function do?
• What is a shebang line?
• What is the Python interactive shell?

Quick Interview Answer

I create a file with a .py extension, write Python code in it, and run it from a terminal. On Windows I usually use python file.py or py file.py. On Linux and macOS I usually use python3 file.py. I can also run the file from an editor such as VS Code.

Key Takeaways

• Python programs are usually saved in .py files.
• print() displays text or values.
• Use python or py on Windows and python3 on macOS/Linux.
• The terminal must be in the correct folder before you run a file.
• VS Code can run Python files directly.

Chapter practice checkpoint

Run python --version (or python3 --version on systems using that command). Save print("Hello, automation!") in hello.py, then run it from the terminal with python hello.py.

Expected output: Hello, automation! on its own line.

Knowledge check: What is the difference between the interpreter prompt and a saved script?

You are ready to continue when you can locate your script, run it, change its message, and explain the output.

1.1 What Is Python Syntax?

Syntax means the rules for writing valid Python code. Just as a sentence needs correct grammar, a Python program needs correct syntax.

For example, this is valid Python:

print("Python is easy to read")

Python understands the print() function and the text inside the quotes.

1.2 Why Does Syntax Matter?

Python checks your syntax before it runs the program. If the syntax is incorrect, Python stops and shows an error.

print("Hello")

This code is valid. The following code is missing a closing parenthesis:

print("Hello"

Python reports a SyntaxError because it cannot understand the line.

1.3 Python Reads Code from Top to Bottom

Python normally runs statements in order, starting with the first line:

print("Step 1")
print("Step 2")
print("Step 3")

The output is:

Step 1
Step 2
Step 3

This makes the order of your code important.

1.4 Python Uses Indentation

Indentation means spaces at the beginning of a line. Python uses indentation to show which lines belong inside a block.

age = 20

if age >= 18:
  print("You are an adult")

The indented print() line belongs to the if statement.

Use four spaces for each indentation level:

if True:
  print("This line is inside the if block")

Do not use random numbers of spaces:

if True:
  print("This may cause an indentation problem")

Most editors can insert four spaces automatically when you press Tab.

1.5 Colons Start Code Blocks

Statements such as if, for, while, and function definitions use a colon at the end of the first line:

if 10 > 5:
  print("The condition is true")

The colon tells Python that an indented block is coming next.

1.6 Comments

Comments are notes for people reading the code. Python ignores comments when it runs the program.

# Check whether the server is healthy
server_is_healthy = True
print(server_is_healthy)

Use comments to explain why something is done when the code is not obvious.

1.7 Names and Values

You can store a value in a variable by giving it a name:

server_name = "web-01"
server_port = 8080

print(server_name)
print(server_port)

Use clear names with lowercase letters and underscores:

retry_count = 3

Avoid unclear names:

x = 3

Python names cannot contain spaces and cannot start with a number.

1.8 Syntax Errors and Logic Errors

Syntax Error

A syntax error means Python cannot understand the code. The program stops before it starts:

if True
  print("Hello")

This code is missing a colon.

Logic Error

A logic error means the code is valid, but the result is wrong:

price = 100
discount = 20

final_price = price + discount  # The intended operation was probably subtraction.
print(final_price)

Python runs this code because the syntax is valid. It cannot know what result you intended.

1.9 Syntax Error and Runtime Error

A runtime error happens while the program is running:

server_count = 3
print(server_count + " servers")

Python cannot add a number and text, so it raises an error when it reaches that line.

Remember:

1.10 Practice Exercise

Create a file named syntax-practice.py:

name = "Alex"
age = 25

if age >= 18:
  print(f"{name} is an adult")
else:
  print(f"{name} is a minor")

Run the file and then change the value of age. Observe how the output changes.

Interview Questions

• What is syntax in Python?
• Why is indentation important in Python?
• What does a colon mean after an if statement?
• What is the difference between a syntax error and a logic error?
• What is the difference between a runtime error and a syntax error?
• How should Python variables be named?

Quick Interview Answer

Python syntax is the set of rules used to write valid Python code. Python uses indentation to define code blocks, and statements such as if and for use a colon before an indented block. A syntax error stops the program before it runs, while a logic error allows the program to run but produces the wrong result.

Key Takeaways

• Syntax is the grammar of Python code.
• Python reads code from top to bottom.
• Indentation defines blocks of code.
• Colons start blocks after statements such as if and for.
• Comments begin with #.
• Syntax errors stop a program before it runs.
• Logic errors produce incorrect results without necessarily showing an error.

1.1 What Is the Structure of a Python Program?

The structure of a Python program means the way the code is organized in a file.

A small Python file may contain only one line:

print("Hello")

As the program becomes larger, organizing the code makes it easier to read, test, and update.

1.2 A Common Python File Layout

Many Python files follow this order:

1. Imports
2. Constants and configuration
3. Functions
4. Classes, when needed
5. The main program

1.3 Imports

An import loads code that you want to use. In this example, platform is a standard Python module:

import platform

print(platform.system())

Imports are usually placed at the top of the file so readers can quickly see what the program needs.

1.4 Constants and Configuration

Constants are values that normally do not change while the program runs. Python developers commonly write constant names in uppercase:

MAX_RETRIES = 3
DEFAULT_REGION = "us-east-1"

Do not store passwords, API keys, or other secrets directly in a Python file.

1.5 Functions

A function is a named group of instructions. It runs when you call it.

def greet_user(name):
    print(f"Hello, {name}!")


greet_user("Alex")

Defining a function does not run its instructions immediately. The function runs only when you call it.

1.6 The main() Function

The main() function usually contains the main steps of a script:

def main():
    print("Checking the server")


main()

Using a main() function keeps the starting point of the program clear.

1.7 The if __name__ == "__main__": Check

This common Python line means: run the following code only when this file is started directly.

def main():
    print("The script is running")


if __name__ == "__main__":
    main()

The check is useful because another Python file can import your functions without automatically starting the whole script.

1.8 How Python Runs the File

Python reads top-level code from top to bottom. It creates functions when it reaches their definitions, then runs the code that calls them.

print("1. Start")


def show_message():
    print("2. Inside the function")


print("3. Before the function call")
show_message()

The output is:

1. Start
3. Before the function call
2. Inside the function

1.9 Write Readable Python

Good structure helps other people understand your code.

• Use clear names such as server_count instead of x.
• Keep functions small and focused.
• Use four spaces for indentation.
• Put imports at the top.
• Keep configuration separate from the main logic.

1.10 Practice Exercise

Create a file named server_check.py:

import platform


def show_server_info():
    print(f"Operating system: {platform.system()}")
    print("Server check complete")


def main():
    show_server_info()


if __name__ == "__main__":
    main()

Run it with:

python3 server_check.py

On Windows, use:

python server_check.py

Quick Interview Answer

A Python file commonly contains imports, configuration values, functions, classes when needed, and a main program section. The if __name__ == "__main__": check runs the main function only when the file is executed directly. This allows the same file to work as both a script and an importable module.

Key Takeaways

• Organize Python code into clear sections.
• Put imports near the top of the file.
• Use functions to group reusable work.
• Use main() as the clear starting point of a script.
• Use the __main__ check to prevent code from running during import.
• Clear structure makes Python scripts easier to read and test.

1.1 What Is a Statement?

A statement is an instruction that tells Python to do something.

name = "Alex"
print(name)

The first statement stores a name. The second statement displays it.

Python normally runs statements from top to bottom.

1.2 Simple Statements

A simple statement usually fits on one line and performs one action.

server_count = 3              # assignment
print(server_count)            # function call
import platform                # import

Other common simple statements include return, break, and continue inside functions or loops.

1.3 Compound Statements

A compound statement controls a block of code. Its first line ends with a colon, and the lines below it are indented.

server_status = "running"

if server_status == "running":
    print("The server is healthy")

The if line is the header. The indented print() line is the body.

Common compound statements include:

• if for decisions
• for and while for loops
• def for functions
• class for classes
• try for error handling

1.4 Statements with Conditions

An if statement runs its block only when the condition is true:

disk_usage = 70

if disk_usage > 80:
    print("Disk usage is high")
else:
    print("Disk usage is normal")

The else block runs when the if condition is false.

1.5 Statements with Loops

A for statement repeats a block for each item:

servers = ["web-01", "web-02", "web-03"]

for server in servers:
    print(server)

The output is:

web-01
web-02
web-03

1.6 Multiple Statements on One Line

Python allows multiple simple statements on one line with semicolons:

first_name = "Alex"; print(first_name)

However, this style is harder to read. Write one statement per line instead:

first_name = "Alex"
print(first_name)

One statement per line is the usual Python style and makes errors easier to find.

1.7 Long Statements on Multiple Lines

Long statements can be split across lines inside brackets:

server_names = [
    "web-01",
    "web-02",
    "web-03",
]

Python understands that the list continues until the closing bracket.

You can also use parentheses for a long calculation:

total_cost = (
    monthly_compute_cost
    + monthly_storage_cost
    + monthly_network_cost
)

This is easier to read than one very long line.

Avoid using a backslash for line continuation when brackets can be used:

total = (
    first_value
    + second_value
)

1.8 The pass Statement

The pass statement does nothing. It is useful when you want to create a block and add the real code later:

def check_server():
    pass

Without pass, Python would report an error because the function has no body.

1.9 A Complete Example

This example combines assignments, a condition, a function, and a loop:

servers = ["web-01", "web-02"]
healthy_servers = 0


def show_server(server):
    print(f"Checking {server}")


for server in servers:
    show_server(server)
    healthy_servers += 1


print(f"Healthy servers: {healthy_servers}")

1.10 Practice Exercise

Create a program that checks a list of server statuses:

server_statuses = ["running", "stopped", "running"]

for status in server_statuses:
    if status == "running":
        print("Server is healthy")
    else:
        print("Server needs attention")

Change the list and observe how the output changes.

Interview Questions

• What is a statement in Python?
• What is the difference between a simple and compound statement?
• Why does a compound statement need a colon?
• Why is indentation important after a compound statement?
• Can you place multiple statements on one line?
• How can you split a long statement across multiple lines?

Quick Interview Answer

A statement is an instruction for Python to execute. A simple statement usually performs one action on one line, such as an assignment or function call. A compound statement, such as if, for, or def, ends with a colon and contains an indented block. Python allows semicolons, but one statement per line is easier to read.

Key Takeaways

• A statement is an instruction for Python.
• Simple statements usually fit on one line.
• Compound statements contain an indented block.
• Compound statement headers end with a colon.
• Prefer one statement per line.
• Use brackets or parentheses to split long statements. 1 2

## Line Continuation

### What Is It?

Splitting one logical statement across multiple physical lines, either explicitly with a trailing backslash or implicitly inside brackets.

### Why Is It Used?

It keeps long expressions readable instead of one very long line.

### How Is It Used?

See [4.15 Multiple Statements & Line Continuation](../15-multiple-statements-and-line-continuation/) for the full comparison of both styles.

```python
total = 1 + \
        2 + \
        3
>>> total
6

Quick Interview Answer

“A simple statement fits on one line and does one thing — an assignment, a function call, an import. A compound statement has a colon-terminated header and an indented block beneath it — if, for, def, class. You can technically cram multiple simple statements onto one line with semicolons, but PEP 8 discourages it.”

Common Mistakes

• Forgetting the colon at the end of a compound statement’s header line — the single most common beginner SyntaxError.
• Overusing semicolons to combine simple statements, which hurts readability without any real performance benefit.

1.1 What Is Indentation?

Indentation means spaces at the beginning of a line. Python uses indentation to show which lines belong together.

In many languages, braces mark a block. Python uses indentation instead:

if temperature > 30:
    print("It is hot")

The indented print() line belongs to the if statement.

1.2 The Basic Rule

When a line ends with a colon, the next related lines must be indented:

if server_status == "running":
    print("Server is running")

Statements at the same level should have the same indentation:

if server_status == "running":
    print("Server is running")
    print("Health check passed")

1.3 Use Four Spaces

The usual Python style is four spaces for each indentation level:

if True:
    print("Level one")

Most code editors insert four spaces when you press Tab. Configure your editor to use spaces instead of tabs for Python files.

1.4 Indentation in Functions and Loops

Indentation is used with functions, loops, conditions, and other blocks:

def check_servers(servers):
    for server in servers:
        print(f"Checking {server}")

The indentation shows the relationship:

def check_servers        level 0
    for server           level 1
        print(...)       level 2

1.5 Nested Blocks

A nested block is a block inside another block. Add one indentation level for each new block:

servers = ["web-01", "web-02"]

for server in servers:
    if server == "web-01":
        print(f"Checking important server: {server}")
    else:
        print(f"Checking server: {server}")

The if statement is inside the for loop, so it has more indentation.

1.6 Incorrect Indentation

This code causes an error because the line after the colon is not indented:

if True:
print("This is not inside the if block")

Python reports an IndentationError.

Correct it by adding four spaces:

if True:
    print("This is inside the if block")

1.7 Inconsistent Indentation

Lines in the same block must use the same indentation:

if True:
    print("First line")
  print("Second line")

The second line does not line up with the first line, so Python may report an IndentationError.

1.8 Do Not Mix Tabs and Spaces

Mixing tabs and spaces can cause a TabError or make the code difficult to read.

Use your editor’s Python formatting settings to insert spaces. In VS Code, you can use the indentation indicator in the bottom status bar to convert indentation to spaces.

1.9 Indentation with else

The else statement must line up with its matching if:

disk_usage = 70

if disk_usage > 80:
    print("Disk usage is high")
else:
    print("Disk usage is normal")

The code inside each branch is indented, but if and else are at the same level.

1.10 Practice Exercise

Create a file named indentation-practice.py:

services = ["api", "database", "cache"]

for service in services:
    if service == "database":
        print(f"Checking critical service: {service}")
    else:
        print(f"Checking service: {service}")

Change the indentation intentionally and observe the error. Then fix the indentation and run the program again.

Interview Questions

• Why is indentation important in Python?
• How many spaces are normally used for one indentation level?
• What happens when indentation is missing after a colon?
• What is a nested block?
• Why should tabs and spaces not be mixed?
• How should else align with if?

Quick Interview Answer

Python uses indentation to define blocks of code instead of braces. Lines in the same block must have the same indentation, and a new block normally uses four spaces. Indentation is required after statements such as if, for, and def, and mixing tabs and spaces can cause an error.

Key Takeaways

• Indentation is part of Python syntax.
• Use four spaces for each indentation level.
• Indent code after a line ending with :.
• Keep statements in the same block aligned.
• Use more indentation for nested blocks.
• Do not mix tabs and spaces.

1.1 What Is a Comment?

A comment is a note written for people reading the code. Python ignores comments when it runs the program.

Comments are useful when they explain a decision, a warning, or a part of the code that is not obvious.

1.2 Single-Line Comments

Start a comment with #. Everything after # on that line is ignored:

# Check the API three times because the service may respond slowly.
max_retries = 3

You can also place a short comment after code:

timeout_seconds = 30  # Keep the request from waiting forever.

Use an end-of-line comment only when it remains easy to read.

1.3 Comments Before Code

A comment can explain the purpose of the next few lines:

# Skip temporary files before uploading the directory to S3.
for file_name in files:
    if not file_name.endswith(".tmp"):
        upload(file_name)

The comment explains why the condition exists. The code already shows what the condition does.

1.4 Multi-Line Comments

Python does not have a special multi-line comment symbol. For a longer comment, use # on each line:

# This script checks the health of each service.
# It prints a warning when a service is not running.
# The output can be used by a monitoring job.

This is the clearest and most reliable way to write a multi-line comment.

1.5 Comments and Triple Quotes Are Different

Triple quotes create a string, not a real multi-line comment:

"""
This looks like a comment,
but Python treats it as a string.
"""

An unused string may appear to work like a comment, but it is not the correct general-purpose comment style. Use # for comments.

1.6 What Is a Docstring?

A docstring is text that documents a module, function, class, or method. It is written inside triple quotes as the first statement in that object.

def check_server(server_name):
    """Return the health status of a server."""
    return f"{server_name} is healthy"

Unlike a normal comment, a docstring is available while the program runs:

print(check_server.__doc__)

Output:

Return the health status of a server.

Python’s help() function and many editors can display docstrings:

help(check_server)

1.7 Function Docstrings

Use a function docstring to explain what the function does, its inputs, and its result when that information is useful:

def calculate_retry_delay(attempt, base_delay=2):
    """Return the delay before the next retry attempt."""
    return base_delay ** attempt

The function name and code show how it works. The docstring gives a short explanation for someone who wants to use it.

1.8 Module and Class Docstrings

A module docstring goes at the top of a Python file:

"""Tools for checking application health."""

import requests

A class docstring goes immediately inside the class:

class HealthChecker:
    """Check whether an application endpoint is responding."""

    pass

1.9 Good and Bad Comments

This comment does not add much information:

# Add one to count.
count = count + 1

The code is already clear. This comment is more useful:

# Count only successful responses so failed checks are reported separately.
successful_checks += 1

Good comments usually explain why, not only what.

1.10 Keep Comments Correct

Update a comment when the code changes. A comment that disagrees with the code can mislead someone:

# Retry five times.
for attempt in range(3):
    retry_request()

The comment and code disagree. Change one of them so they describe the same behavior.

1.11 Comments in DevOps Scripts

Comments are especially useful in automation scripts for explaining:

• Why a retry or timeout value was chosen
• Why a resource is skipped
• What permission a cloud API call requires
• Why a command is safe or potentially destructive
• What format an input file must use

# The cleanup is limited to objects older than 30 days.
# Do not remove newer objects because they may be needed for recovery.
if object_age_days > 30:
    delete_object(object_name)

Never put passwords, access keys, tokens, or other secrets in comments. Comments are stored in the source code and may be shared with the repository.

1.12 Practice Exercise

Add useful comments and a docstring to this script:

def check_services(services):
    """Print the status of each service in the list."""
    for service in services:
        # Treat only running services as healthy.
        if service["status"] == "running":
            print(f"{service['name']} is healthy")
        else:
            print(f"{service['name']} needs attention")


services = [
    {"name": "api", "status": "running"},
    {"name": "worker", "status": "stopped"},
]

check_services(services)

Add one comment explaining a decision, then add a docstring to the function.

Interview Questions

• What is a comment in Python?
• How do you write a single-line comment?
• How do you write a multi-line comment?
• Are triple-quoted strings the same as comments?
• What is a docstring?
• Where should a function docstring be placed?
• What is the difference between a comment and a docstring?
• What makes a comment useful?

Quick Interview Answer

A Python comment starts with #, and Python ignores it when running the program. Python does not have a special multi-line comment syntax, so we use # on each line. A docstring is different: it is a triple-quoted string placed first inside a module, function, or class, and it can be viewed through __doc__ or help().

Key Takeaways

• Use # to write comments.
• Use comments to explain why code exists.
• Use one # on each line for multi-line comments.
• Use docstrings to document reusable functions, classes, and modules.
• Keep comments short, clear, and up to date.
• Never store secrets in source code comments.

What Are Keywords?

What Is It?

Reserved words that are part of Python’s own syntax (if, for, def, class, …). The language grammar gives them special meaning, so they cannot be used as ordinary names.

Why Does It Matter?

Attempting to use a keyword as a variable name is a SyntaxError, not a warning.

>>> class = 5
  File "<stdin>", line 1
    class = 5
    ^^^^^
SyntaxError: invalid syntax

Complete Keyword List

Python 3.12 has 35 keywords, retrievable programmatically via the keyword module:

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await',
'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try',
'while', 'with', 'yield']
>>> len(keyword.kwlist)
35

Python’s 35 keywords, grouped by purpose.

Hard Keywords vs Soft Keywords

Hard Keywords

Hard keywords are always reserved. The parser recognizes them wherever an identifier could otherwise appear, so names such as class, for, and return are invalid in every context.

class = "deployment"  # SyntaxError: invalid syntax

Soft Keywords

Soft keywords are reserved only in specific grammar contexts. In Python 3.10 and later, match and case are soft keywords used by structural pattern matching. The underscore (_) also has special pattern-matching behavior. Python 3.12 adds type as a soft keyword for type alias statements.

match status:
  case 200:
    message = "ok"
  case _:
    message = "unexpected status"

# Outside a match statement, these names can still be used normally.
match = "rolling"
type = "service"

Use keyword.softkwlist when code must account for contextual keywords as well as the hard keyword list:

>>> import keyword
>>> keyword.softkwlist
['_', 'case', 'match', 'type']

The exact list is version-dependent. Check the interpreter that will run the code rather than hard-coding a count.

Keywords by Role

Checking Names Safely

An identifier must pass both checks: it must have valid identifier syntax and must not be reserved by the interpreter.

import keyword


def is_available_name(candidate: str) -> bool:
  return candidate.isidentifier() and not keyword.iskeyword(candidate)


for candidate in ("service_name", "2services", "class"):
  print(candidate, is_available_name(candidate))

Expected output:

service_name True
2services False
class False

str.isidentifier() checks the shape of a name; keyword.iskeyword() checks whether the interpreter reserves it. Neither check prevents shadowing a built-in such as list or type, so use clear project-specific names and follow 4.16 Coding Standards (PEP 8).

Practical DevOps Example

Keywords frequently appear in automation scripts that inspect command results and handle failures:

import subprocess


def check_service(service_name: str) -> str:
  try:
    result = subprocess.run(
      ["systemctl", "is-active", service_name],
      check=True,
      capture_output=True,
      text=True,
    )
  except subprocess.CalledProcessError as error:
    raise RuntimeError(f"Unable to inspect {service_name}") from error
  else:
    return result.stdout.strip()
  finally:
    print(f"Finished checking {service_name}")

Here, def, try, except, raise, from, else, and finally are keywords that define the control flow. The service name remains data supplied to the function, not a dynamically constructed piece of Python syntax.

How Python Handles a Keyword Error

Python parses source code before executing it. If a hard keyword appears where an identifier is required, parsing stops and no statements from that module run.

This is why a keyword naming error cannot be fixed with try/except: the try block itself cannot execute until the source has successfully parsed.

Using help('keywords')

How Is It Used?

The interactive help system lists and explains every keyword directly from the interpreter, without needing internet access:

>>> help("keywords")
Here is a list of the Python keywords.  Enter any keyword to get more help.

False               class               from                or
None                continue            global              pass
...

Restrictions

Keywords cannot be used as variable, function, or class names. Use keyword.iskeyword() to check programmatically before using a name you’re unsure about:

>>> keyword.iskeyword("for")
True
>>> keyword.iskeyword("variable")
False

Keywords Are Not the Same as Built-ins

class is a keyword and cannot be assigned. list, type, and id are built-in names, not hard keywords, so Python permits them but shadowing them can break later code:

list = ["api", "worker"]
print(list("abc"))  # TypeError: 'list' object is not callable

Use a descriptive name such as services instead. This distinction is a common interview follow-up.

Troubleshooting Checklist

When Python reports a keyword-related SyntaxError:

1. Read the caret (^) location, then inspect the complete statement around it.
2. Check whether a variable, function, parameter, or class has the same spelling as a hard keyword.
3. Run python -m py_compile your_script.py to catch parse errors without executing the script.
4. Check the interpreter version with python --version; keyword behavior can differ between Python versions.
5. Rename the identifier rather than trying to quote or escape it. Python has no escape syntax that turns a keyword into an ordinary identifier.

Quick Interview Answer

“Keywords are the 35 reserved words baked into Python’s grammar — if, for, def, class, import, and so on. They can never be used as an identifier; trying raises a SyntaxError immediately, not a runtime warning. You can list them at any time with keyword.kwlist or check a specific name with keyword.iskeyword().”

Common Mistakes

• Trying to name a variable class, type, or list — class is a hard keyword (fails outright); type and list are built-in names, not keywords, so they’re technically legal but silently shadow the built-in.
• Assuming the keyword count never changes across versions — soft keywords such as match, case, _, and type behave contextually and are reported separately by keyword.softkwlist.
• Trying to catch a keyword SyntaxError at runtime — parsing happens before execution, so the source must be corrected first.
• Treating a keyword as the same thing as a built-in — keywords are grammar tokens; built-ins are ordinary names initially provided by the built-in namespace.

Interview Follow-up Questions

1. What is the difference between a keyword, a soft keyword, and a built-in name?
2. How can you list Python keywords programmatically?
3. Why can a try/except block not catch class = 1?
4. What are match and case, and why are they not in keyword.kwlist?
5. How would you validate a user-provided name before generating Python source code?

What Are Identifiers?

What Is It?

Identifiers are the names you give to variables, functions, classes, and modules.

Python stores values in objects and uses identifiers as readable references to those objects. An identifier is not the value itself, and assigning a new value to a name does not change the old object.

What Are the Rules?

• It must start with a letter or underscore (not a digit)
• It may contain letters, digits, and underscores after that
• Identifiers are case-sensitive
• It cannot be a keyword

Naming Conventions

See 4.16 Coding Standards (PEP 8) for the full naming table — snake_case for variables/functions, PascalCase for classes, UPPER_SNAKE_CASE for constants.

A leading underscore is a naming convention, not a security boundary. It signals that an identifier is intended for internal use. Python’s name-mangling behavior for __name inside a class is separate from this convention.

Valid vs Invalid Identifiers

How Is It Used?

>>> "valid_name".isidentifier()
True
>>> "2invalid".isidentifier()      # cannot start with a digit
False
>>> "my-var".isidentifier()        # hyphens are not allowed
False

Unicode letters can also be valid in identifiers, but ASCII names are usually easier for teams to search, type, review, and operate across shells and CI systems:

service_name = "api"
π = 3.14159

print(service_name, π)

For production automation, prefer descriptive ASCII identifiers unless the project has a deliberate convention for Unicode names.

How Python Validates an Identifier

Python checks the first character, the remaining characters, and whether the name is reserved. A valid-looking name can still fail the final check if it is a keyword.

import keyword


def can_be_identifier(candidate: str) -> bool:
	return candidate.isidentifier() and not keyword.iskeyword(candidate)


for candidate in ("pod_name", "9pods", "class", "service-name"):
	print(candidate, can_be_identifier(candidate))

Expected output:

pod_name True
9pods False
class False
service-name False

Reserved Words

The 35 keywords from 4.6 Keywords cannot be used as identifiers, even though they otherwise look like valid names — Python’s parser treats them as fixed syntax rather than user-defined names.

Built-in names are different from keywords. Names such as list, type, and id are valid identifiers, but reusing them hides the built-in and can cause a later failure:

list = ["api", "worker"]
print(list("abc"))  # TypeError: 'list' object is not callable

Use names such as services or service_names instead. A linter can catch many shadowing problems before they reach CI.

Scope and Rebinding

An identifier can refer to different objects in different scopes. A local assignment normally does not change a global name with the same spelling:

environment = "production"


def deploy():
	environment = "staging"
	return environment


print(deploy())       # staging
print(environment)    # production

The function’s environment is a local identifier. Use global or nonlocal only when rebinding an outer name is intentional; passing values and returning results is usually easier to test.

Practical DevOps Example

Clear identifiers make automation scripts easier to review and reduce mistakes when several configuration values have similar meanings:

import os


DEFAULT_REGION = "us-east-1"


def deployment_target() -> tuple[str, str]:
	region = os.getenv("AWS_REGION", DEFAULT_REGION)
	cluster_name = os.environ["EKS_CLUSTER_NAME"]
	return cluster_name, region


cluster_name, region = deployment_target()
print(f"Deploying to {cluster_name} in {region}")

DEFAULT_REGION communicates a constant, while cluster_name and region communicate values that can change. Avoid vague names such as x, data, or value when the script performs infrastructure operations.

Quick Interview Answer

“An identifier must start with a letter or underscore, contain only letters/digits/underscores after that, and can’t be a keyword. Identifiers are case-sensitive — total and Total are different names. Use str.isidentifier() to check programmatically, and keyword.iskeyword() to check whether a valid-looking name is actually reserved.”

Troubleshooting Checklist

When Python reports an invalid identifier:

1. Check that the first character is not a digit.
2. Replace hyphens, spaces, and punctuation with underscores.
3. Check the spelling against keyword.kwlist if the name looks like Python syntax.
4. Look for invisible or non-ASCII characters copied from documentation.
5. Check for accidental built-in shadowing such as list = ... or id = ....
6. Run python -m py_compile your_script.py to catch parsing errors before executing the script.

Interview Follow-up Questions

1. What is the difference between an identifier and a variable in Python?
2. Why are total and Total different identifiers?
3. How do str.isidentifier() and keyword.iskeyword() differ?
4. Is _name private in Python?
5. What problem is caused by assigning a value to list or id?
6. How does local scope affect an identifier with the same name as a global variable?

Common Mistakes

• Starting an identifier with a digit (2invalid) — always a SyntaxError.
• Using a hyphen instead of an underscore (my-var) — Python parses the hyphen as a minus operator, not part of the name.
• Assuming identifiers are case-insensitive, then being confused why Username and username are treated as two separate variables.
• Confusing a valid identifier with a good name — data may be legal, but pod_metadata is more useful to the next engineer.
• Treating a leading underscore as access control — it communicates intent but does not prevent access from other code.

Declaring Variables

What Is It?

Unlike many languages, Python has no separate declaration step — a variable comes into existence the moment you assign a value to it.

Why Is It Used?

Less boilerplate, faster to write.

How Is It Used?

Just write name = value.

>>> username = "deploy_bot"
>>> username
'deploy_bot'

Python variables are names, not fixed storage boxes with permanent types. The name username refers to a string object, and a later assignment can make it refer to a different object.

Assignment

The = operator binds a name to a value (technically, to an object in memory). Re-assigning simply points the name at a new object; it doesn’t modify the old one.

>>> retries = 3
>>> retries = retries + 1
>>> retries
4

Names and Objects

Assignment creates or updates a binding between a name and an object. It does not copy the object automatically.

The old integer object is not changed. The name is simply rebound to the result of retries + 1.

Use == to compare values and is only to compare object identity. In normal application code, is is most commonly used with the singleton None:

value = None

if value is None:
	print("No value was supplied")

Multiple Assignment

What Is It?

Assigning several variables in one statement, either to different values or the same one.

Why Is It Used?

It reduces repetition when initializing related variables together.

>>> a, b, c = 1, 2, 3    # unpack three values at once
>>> a, b, c
(1, 2, 3)

>>> x = y = z = 0        # all three names point at the same value
>>> x, y, z
(0, 0, 0)

Python also supports starred unpacking when the number of remaining values is variable:

>>> first, *middle, last = [10, 20, 30, 40]
>>> first, middle, last
(10, [20, 30], 40)

The number of values must still be compatible with the assignment pattern. Otherwise Python raises ValueError.

Mutable Objects and Aliasing

Multiple names can refer to the same mutable object. Mutating the object is visible through every alias, while rebinding one name is not:

>>> primary = []
>>> secondary = primary
>>> secondary.append("api")
>>> primary
['api']
>>> secondary = ["worker"]
>>> primary
['api']

This is why a mutable default argument is dangerous:

def add_service(service_name, services=[]):
	services.append(service_name)
	return services

The same list is reused between calls. Use None as a sentinel and create the list inside the function instead:

def add_service(service_name, services=None):
	if services is None:
		services = []
	services.append(service_name)
	return services

Type Annotations

Annotations document the expected type without changing Python’s dynamic runtime behavior. Python does not enforce the annotation by itself:

retries: int = 3
service_name: str = "api"

retries = "three"  # Allowed at runtime, but a type checker should report it.

Use annotations for function boundaries and configuration data, then use a type checker such as Pyright or mypy in CI when the project requires static checks.

Dynamic Typing

Covered in depth in Introduction to Python, Section 1.3 — a variable’s type is simply whatever its current value’s type is, and can change on reassignment:

>>> v = 10
>>> type(v)
<class 'int'>
>>> v = "text"
>>> type(v)
<class 'str'>

Dynamic typing does not mean a value has no type. Every object has a type; it means the name is not permanently restricted to one type by the language.

Variables in DevOps Scripts

Keep external configuration at the boundary of a script, validate it, and pass explicit values to the functions that need them:

import os


def get_deployment_config() -> tuple[str, str]:
	cluster_name = os.environ.get("EKS_CLUSTER_NAME")
	region = os.environ.get("AWS_REGION", "us-east-1")

	if not cluster_name:
		raise RuntimeError("EKS_CLUSTER_NAME is required")

	return cluster_name, region


cluster_name, region = get_deployment_config()
print(f"Deploying {cluster_name} in {region}")

This keeps secrets and environment-specific values outside the source code while making the function’s inputs clear and testable. Do not print secret environment variables in CI logs.

Variable Scope

A name created inside a function is local to that function unless the code explicitly refers to an outer scope:

environment = "production"


def target_environment():
	environment = "staging"
	return environment


print(target_environment())  # staging
print(environment)           # production

Prefer function parameters and return values over global state. Explicit data flow is easier to test and safer when automation runs concurrently.

Quick Interview Answer

“A Python variable is just a name bound to an object — there’s no separate declaration step, no type annotation required. x = y = z = 0 binds all three names to the same object; a, b, c = 1, 2, 3 unpacks three values in one line. Because a name is just a label, reassigning it to a different type is perfectly legal — that’s what ‘dynamically typed’ means.”

Troubleshooting Checklist

When a variable behaves unexpectedly:

1. Print or inspect its value and type(value).
2. Check whether the name was accidentally rebound later in the function.
3. For mutable values, inspect whether two names refer to the same object with is.
4. Use == for value comparison and is None for the absence of a value.
5. Check unpacking counts when Python raises ValueError.
6. Review environment-variable defaults and validate required configuration before use.

Interview Follow-up Questions

1. Is a Python variable a box, a pointer, or a name bound to an object?
2. What is the difference between rebinding and mutating an object?
3. Why does x = y = [] create an aliasing problem?
4. What is the difference between == and is?
5. Do type annotations enforce types at runtime?
6. Why is None a safer default sentinel than an empty mutable list?

Common Mistakes

• Assuming x = y = [] creates two separate lists — it creates one list object that both names point to, so mutating it through either name affects both.
• Forgetting that reassignment doesn’t mutate the old value — it just points the name at a new object, leaving the old one unchanged (and eventually garbage-collected if nothing else references it).
• Using a mutable list or dictionary as a default function argument — the same object persists across calls.
• Using is for ordinary value comparison — use == unless object identity is specifically what you need.
• Believing annotations enforce types — they document intent and support tools, but Python does not enforce them automatically.

Concept of Constants

What Is It?

A value that’s meant to never change after it’s set.

Why Doesn’t Python Enforce It?

Python has no true language-enforced constant — unlike const in other languages, nothing stops you from reassigning an UPPER_CASE name. “Constants” in Python are a naming convention, not a compiler guarantee.

Naming Convention

How Is It Used?

Constants are written in UPPER_SNAKE_CASE to visually signal “don’t reassign this” to anyone reading the code:

MAX_RETRIES = 3
DEFAULT_TIMEOUT = 30
API_BASE_URL = "https://api.example.com"

Best Practices

• Define constants at the top of the module, right after imports
• Use UPPER_SNAKE_CASE consistently so violations of the convention stand out
• For values that truly must be immutable, use a tuple or Enum rather than relying on naming alone

Quick Interview Answer

“Python has no const keyword — a ‘constant’ is purely a naming convention: UPPER_SNAKE_CASE, defined at the top of a module, meant to signal ‘don’t reassign this.’ Nothing at the language level actually prevents reassignment. If true immutability matters, use a tuple or an Enum instead of relying on the naming convention alone.”

Common Mistakes

• Believing UPPER_CASE = value is protected from reassignment the way const is in JavaScript or Java — it is not; it’s purely convention.
• Defining constants scattered throughout a module instead of grouped at the top, making them harder for a reader to find.

A literal is a value written directly in source code, as opposed to one computed at runtime — 42, "hello", and True are all literals.

Numeric Literals

>>> type(10)         # int
<class 'int'>
>>> type(10.5)        # float
<class 'float'>
>>> type(1 + 2j)      # complex
<class 'complex'>

String Literals

Covered in depth in Chapter 9: Strings — single, double, and triple quotes all produce str literals.

>>> type("hello")
<class 'str'>

Boolean Literals

>>> type(True)
<class 'bool'>

None

What Is It?

Python’s explicit “no value” placeholder — its own type, distinct from 0, False, or an empty string.

Why Is It Used?

To represent the deliberate absence of a value, e.g. a function that has nothing meaningful to return.

>>> type(None)
<class 'NoneType'>

Collection Literals

>>> type([1, 2])        # list
<class 'list'>
>>> type((1, 2))         # tuple
<class 'tuple'>
>>> type({1, 2})         # set
<class 'set'>
>>> type({"a": 1})       # dict
<class 'dict'>

Quick Interview Answer

“A literal is a value written directly into source code rather than computed — numeric (int, float, complex), string, boolean (True/False), None, and the collection literals [], (), {} for list/tuple/set/dict. None is its own distinct type, NoneType — not the same as 0, False, or "".”

Common Mistakes

• Treating None, 0, False, and "" as interchangeable — they’re all “falsy” in a boolean context, but None specifically represents the absence of a value, not a zero or empty one.
• Writing {} expecting an empty set — {} is actually an empty dict; an empty set requires set().

What Is input()?

input() reads one line from standard input, optionally displays a prompt, waits until the user presses Enter, removes the line ending, and returns the remaining text as a string.

It is useful for small interactive command-line scripts. It is not a replacement for a full command-line argument parser, environment variables, or a secret manager in production automation.

Basic Syntax

value = input(prompt)

The prompt argument is optional and must be a string. Python writes it to the console without adding a newline, then waits for input.

name = input("Enter your name: ")
print(f"Hello, {name}!")

Example interaction:

Enter your name: Alice
Hello, Alice!

The prompt can be omitted:

print("Enter the environment name:")
environment = input()

The value is assigned only when the user enters a line. input() does not automatically validate, convert, or hide anything typed by the user.

Important Properties

It Always Returns str

Even when the user enters digits, the result is text.

replica_text = input("Number of replicas: ")
print(type(replica_text))  # <class 'str'>

replicas = int(replica_text)
print(replicas + 1)

Without conversion, "3" + "1" produces "31", not 4, and "3" + 1 raises TypeError.

It Reads One Line

The user can type spaces inside the line, but pressing Enter finishes that call. To read several lines, call input() repeatedly or use a loop.

first_line = input("First line: ")
second_line = input("Second line: ")

It Removes the Trailing Newline

Unlike sys.stdin.readline(), the returned value does not include the final \\n. It can still contain leading or trailing spaces, so .strip() is often useful.

service = input("Service name: ").strip()

Common Ways to Use input()

Read Plain Text

region = input("AWS Region: ").strip()

Convert to an Integer

port = int(input("Port: "))

Use this only when invalid text should stop the program. For user-facing tools, catch ValueError and show a helpful message.

Convert to a Decimal Number

threshold = float(input("CPU threshold (%): "))

For currency or exact decimal values, prefer decimal.Decimal instead of float.

Parse a Boolean Safely

Do not use bool(input("Enable feature? ")): every non-empty string, including "no", is truthy.

answer = input("Enable monitoring? (yes/no): ").strip().lower()
if answer in {"yes", "y"}:
  monitoring_enabled = True
elif answer in {"no", "n"}:
  monitoring_enabled = False
else:
  raise ValueError("Enter yes or no")

Read Several Values from One Line

split() separates whitespace-delimited values. Convert each item when numeric input is expected.

raw_ports = input("Ports, separated by spaces: ")
ports = [int(port) for port in raw_ports.split()]
print(ports)

For comma-separated values, provide the separator explicitly:

raw_tags = input("Tags, separated by commas: ")
tags = [tag.strip() for tag in raw_tags.split(",") if tag.strip()]

Use a Default Value

An empty response can mean “use the default”. The or expression handles that case.

region = input("AWS Region [us-east-1]: ").strip() or "us-east-1"

Ask Until the Value Is Valid

This is the standard pattern for a small interactive tool.

while True:
  try:
    replicas = int(input("Replicas (1-20): "))
    if 1 <= replicas <= 20:
      break
    print("Enter a number from 1 to 20.")
  except ValueError:
    print("Enter a whole number.")

print(f"Deploying {replicas} replicas.")

Choose from a Menu

actions = {"1": "status", "2": "logs", "3": "restart"}
choice = input("1) status  2) logs  3) restart: ").strip()

if choice not in actions:
  raise ValueError("Unknown action")
print(f"Selected action: {actions[choice]}")

Read Multiple Lines

commands = []
for number in range(3):
  commands.append(input(f"Command {number + 1}: ").strip())

For an unknown number of lines, use a sentinel such as "done":

lines = []
while True:
  line = input("Enter a line, or done: ").strip()
  if line.lower() == "done":
    break
  lines.append(line)

Handling Errors and Interruptions

Invalid conversion raises ValueError. End-of-file, common when stdin is redirected or a CI job provides no input, raises EOFError. Ctrl+C raises KeyboardInterrupt.

try:
  environment = input("Environment: ").strip()
  replicas = int(input("Replicas: "))
except ValueError:
  print("Replicas must be a whole number.")
except EOFError:
  print("No interactive input was provided.")
except KeyboardInterrupt:
  print("\nOperation cancelled.")

input() and Standard Input

input() reads from standard input, so a shell can pipe a value into a script. This is useful for simple, non-secret values.

echo "staging" | python deploy.py

environment = input().strip()
print(f"Received environment: {environment}")

For larger streams, use sys.stdin instead of calling input() one line at a time:

import sys

for line in sys.stdin:
  print(f"Processing: {line.strip()}")

Do not pipe passwords, tokens, or cloud credentials through shell commands because they can appear in shell history, process output, or CI logs.

Cloud and DevOps Examples

Select an AWS Region and Profile

This example uses input for choices while leaving authentication to the AWS SDK credential chain. The user should already have a configured AWS profile; credentials should never be requested with input().

import boto3

region = input("AWS region [us-east-1]: ").strip() or "us-east-1"
profile = input("AWS profile [default]: ").strip() or "default"

session = boto3.Session(profile_name=profile, region_name=region)
ec2 = session.client("ec2")

response = ec2.describe_instances(
  Filters=[{"Name": "instance-state-name", "Values": ["running"]}]
)
running = sum(
  len(reservation["Instances"])
  for reservation in response["Reservations"]
)
print(f"Running instances in {region}: {running}")

In a non-interactive pipeline, pass the region and profile as command-line arguments or environment variables instead. Interactive input can block a deployment job indefinitely.

Confirm a Potentially Destructive AWS Action

Always require an explicit confirmation before deleting or changing infrastructure.

resource_id = input("EC2 instance ID to stop: ").strip()
confirmation = input(
  f"Type STOP to stop {resource_id}, or anything else to cancel: "
).strip()

if confirmation == "STOP":
  print(f"Would stop {resource_id}")
  # ec2.stop_instances(InstanceIds=[resource_id])
else:
  print("Cancelled.")

The example leaves the API call commented out so it cannot change a real account when copied for learning.

Select a Kubernetes Context and Namespace

The input is validated before it is passed to kubectl. In production automation, prefer a reviewed allowlist and avoid constructing shell commands with shell=True.

import subprocess

context = input("kubectl context: ").strip()
namespace = input("Namespace [default]: ").strip() or "default"

if not context or not namespace:
  raise ValueError("Context and namespace are required")

subprocess.run(
  ["kubectl", "--context", context, "--namespace", namespace, "get", "pods"],
  check=True,
)

Build a Docker Image Tag

Validate a release value before using it in a Docker command or CI job.

import re

image = input("Image name [orders-api]: ").strip() or "orders-api"
tag = input("Image tag [latest]: ").strip() or "latest"

if not re.fullmatch(r"[a-z0-9][a-z0-9_.-]*", image):
  raise ValueError("Invalid image name")
if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]*", tag):
  raise ValueError("Invalid image tag")

print(f"docker build --tag {image}:{tag} .")

Choose a Log Level for a Diagnostic Script

import logging

level_names = {"debug": logging.DEBUG, "info": logging.INFO, "warning": logging.WARNING}
level = input("Log level [info]: ").strip().lower() or "info"

if level not in level_names:
  raise ValueError(f"Choose one of: {', '.join(level_names)}")
logging.basicConfig(level=level_names[level])
logging.info("Diagnostic collection started")

Collect a CI/CD Deployment Choice

This is suitable for a manually started local release helper, not an unattended pipeline.

environments = {"1": "dev", "2": "staging", "3": "production"}
choice = input("Deploy to 1) dev  2) staging  3) production: ").strip()

environment = environments.get(choice)
if environment is None:
  raise ValueError("Invalid deployment environment")

if environment == "production":
  confirm = input("Type DEPLOY to continue: ").strip()
  if confirm != "DEPLOY":
    raise SystemExit("Production deployment cancelled")

print(f"Starting deployment to {environment}")

input() Versus Other Configuration Methods

For a hidden password prompt, use getpass:

from getpass import getpass

password = getpass("Password: ")

Even getpass() is usually the wrong place for production cloud credentials. Use IAM roles, workload identity, a CI secret store, or the cloud provider’s credential chain.

Quick Interview Answer

“input(prompt) writes an optional prompt, waits for one line from standard input, removes the trailing newline, and always returns a string. I use .strip() for whitespace, convert explicitly with int() or float(), validate in a loop, and catch ValueError, EOFError, and KeyboardInterrupt where appropriate. For production DevOps automation, I use argparse, environment variables, or a secret manager when the script must be non-interactive or handle sensitive values.”

Common Mistakes

• Assuming input() returns a number. Convert and validate it explicitly.
• Using bool(input(...)) to parse yes/no. Any non-empty string is True.
• Forgetting .strip(), causing a valid-looking choice with extra spaces to fail validation.
• Asking for passwords, API keys, or cloud credentials with input(), which displays the typed value.
• Using input() in unattended CI/CD jobs, where no person is available to answer and the job can hang.
• Passing unchecked input into a shell command. Prefer an argument list with subprocess.run() and validate allowed values.
• Treating an empty response as a valid resource name, region, namespace, or deployment target.

What Is print()?

print() writes values to a text stream, usually the terminal. It accepts zero or more positional values, converts them to text, separates them with sep, and appends end.

print("Hello", "World")

Output:

Hello World

print() is useful for human-readable status messages, command-line tools, quick debugging, and small scripts. For long-running production services, use the logging module so messages have levels, timestamps, and configurable destinations.

Basic Syntax

print(*objects, sep=" ", end="\n", file=None, flush=False)

All arguments after the values are keyword arguments. This is valid:

print("deployment", "complete", sep=" | ", end="!\n")

Output:

deployment | complete!

Printing Values

Print One Value

service = "orders-api"
print(service)

Print Multiple Values

Python converts each value to text for display.

service = "orders-api"
replicas = 3
healthy = True

print(service, replicas, healthy)

Output:

orders-api 3 True

This is usually clearer than manually concatenating strings, and it avoids type errors such as trying to concatenate a string and an integer.

Print No Value

Calling print() with no arguments writes one blank line.

print("Deployment summary")
print()
print("Status: healthy")

Print Collections

Lists and dictionaries are displayed using their normal Python representation.

regions = ["us-east-1", "eu-west-1"]
configuration = {"replicas": 3, "environment": "staging"}

print(regions)
print(configuration)

For machine-readable output, use JSON rather than relying on the Python representation. See Structured JSON Output.

The sep Parameter

sep controls the text inserted between multiple positional values. Its default is one space.

print("api", "staging", "healthy", sep=" | ")

Output:

api | staging | healthy

Useful separators include commas, colons, tabs, and empty text:

print("2026-09-23", "10:30:00", "INFO", sep=" ")
print("name", "status", "latency_ms", sep=",")
print("loading", end="")
print(".", end="")
print(".")

sep is ignored when there is only one object.

The end Parameter

end controls what is written after the final value. The default is a newline.

print("first")
print("second")

Output:

first
second

Set end="" to continue on the same line:

print("Checking", end=" ")
print("database", end=" ")
print("OK")

Output:

Checking database OK

It can also be used for a simple progress display:

for step in range(1, 4):
  print(f"step {step}", end=" ", flush=True)
print("complete")

For a real progress bar, use a library such as tqdm rather than building terminal control behavior manually.

Escape Characters

Escape characters represent special characters inside strings. The complete reference is 4.13 Escape Characters.

print("Line 1\nLine 2")
print("Name\tStatus")
print("She said, \"healthy\"")

Output:

Line 1
Line 2
Name    Status
She said, "healthy"

Use a raw string for text containing many backslashes, such as a Windows path or regular expression:

print(r"C:\\Users\\deploy\\logs")

Formatted Output with f-Strings

f-strings are the preferred way to place expressions inside output text.

service = "payments-api"
status = "healthy"
latency_ms = 42.7

print(f"{service}: {status}, latency={latency_ms:.1f} ms")

Common formatting options:

completion = 0.9375
replicas = 3

print(f"Completion: {completion:.1%}")
print(f"Replicas: {replicas:02d}")
print(f"Cost: ${12.5:,.2f}")

Output:

Completion: 93.8%
Replicas: 03
Cost: $12.50

Expressions can be placed inside braces, but keep complicated logic outside the output statement:

is_healthy = replicas > 0
print(f"Ready: {is_healthy}")

str() and repr() Output

print() uses the readable string form of values. Use repr() when debugging and you need to see quotes, escape characters, or whitespace.

value = "  staging\n"
print(value)
print(repr(value))

Output:

  staging

'  staging\n'

This distinction is useful when diagnosing configuration values that contain unexpected spaces or newlines.

Writing Output to a File or Stream

By default, output goes to sys.stdout. The file parameter sends it to another text stream.

with open("deployment-report.txt", "w", encoding="utf-8") as report:
  print("Deployment completed", file=report)
  print("Environment: staging", file=report)

Use sys.stderr for errors or diagnostic messages that should be separate from normal output:

import sys

print("Deployment started")
print("Warning: replica count is low", file=sys.stderr)

This separation allows a shell or CI system to redirect normal results and errors independently.

Buffering and flush=True

Some streams buffer output before writing it. This can make a long-running script appear stuck, especially when output is sent to a pipe or CI log. flush=True requests immediate flushing.

import time

for item in ["download", "extract", "deploy"]:
  print(f"Starting {item}...", flush=True)
  time.sleep(1)

Use flushing for progress or heartbeat messages, not for every normal log line without a reason.

Structured JSON Output

Human-readable output is useful at a terminal, but automation works better with stable JSON keys.

import json

result = {
  "service": "orders-api",
  "environment": "staging",
  "healthy": True,
  "replicas": 3,
}

print(json.dumps(result))

Pretty-print JSON for people reviewing a report:

print(json.dumps(result, indent=2, sort_keys=True))

Do not print secrets, access tokens, passwords, or complete cloud API responses if they may contain sensitive data.

print() Versus logging

Use print() for short scripts, simple user feedback, and quick demonstrations. Use logging for production services and automation that needs levels, timestamps, handlers, or filtering.

import logging

logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
logging.info("Deployment started")
logging.warning("Rollback threshold is near")

Avoid logging credentials, authorization headers, full environment variables, or sensitive customer data.

Cloud and DevOps Examples

Display an AWS Resource Summary

The SDK response is converted into a small stable summary rather than printing the entire response, which may contain unnecessary details.

import boto3

ec2 = boto3.client("ec2", region_name="us-east-1")
response = ec2.describe_instances(
  Filters=[{"Name": "instance-state-name", "Values": ["running"]}]
)

running_instances = [
  instance
  for reservation in response["Reservations"]
  for instance in reservation["Instances"]
]

print(f"Running instances: {len(running_instances)}")
for instance in running_instances:
  print(instance["InstanceId"], instance.get("InstanceType"), sep=" | ")

In real automation, obtain the region and credentials from the AWS configuration or workload identity rather than hardcoding secrets in output code.

Print an AWS Deployment Result as JSON

import json

deployment = {
  "application": "orders-api",
  "region": "us-east-1",
  "version": "2026.09.23",
  "status": "success",
}
print(json.dumps(deployment))

This format can be consumed by a CI job, monitoring system, or another script.

Report Kubernetes Pod Status

import subprocess

result = subprocess.run(
  ["kubectl", "get", "pods", "--namespace", "staging", "--no-headers"],
  capture_output=True,
  text=True,
  check=True,
)

for line in result.stdout.splitlines():
  columns = line.split()
  if len(columns) >= 3:
    print(f"{columns[0]} | ready={columns[1]} | status={columns[2]}")

Using an argument list avoids shell parsing problems. Do not pass unchecked user input into shell=True.

Show Docker Image Build Progress

import subprocess

image_tag = "orders-api:2026.09.23"
print(f"Building {image_tag}...", flush=True)
subprocess.run(["docker", "build", "--tag", image_tag, "."], check=True)
print(f"Built {image_tag}")

For detailed command output, let the subprocess inherit the terminal or CI stream instead of capturing and printing it only after the command finishes.

Produce a CI/CD Check Result

import json

checks = {
  "unit_tests": "passed",
  "security_scan": "passed",
  "image_scan": "warning",
}

failed = [name for name, status in checks.items() if status == "failed"]
summary = {"checks": checks, "failed": failed, "success": not failed}
print(json.dumps(summary))

A CI job can parse the JSON and decide whether a pipeline stage should continue. Human-facing status messages can still use f-strings.

Print a Log Scanner Summary

from collections import Counter

levels = ["INFO", "ERROR", "INFO", "WARNING", "ERROR"]
counts = Counter(levels)

for level, count in sorted(counts.items()):
  print(f"{level:<8} {count:>4}")

Output:

ERROR       2
INFO        2
WARNING     1

Output Design for Automation

Choose output based on who or what consumes it:

Output should be stable when another program parses it. Avoid adding decorative text to a machine-readable stream such as JSON.

Quick Interview Answer

“print() writes values to a text stream. It accepts any number of objects and supports sep between objects, end after the final object, file for a destination such as a file or sys.stderr, and flush for immediate output. I use f-strings for human-readable messages, json.dumps() for machine-readable results, and logging instead of scattered print() calls in production services.”

Common Mistakes

• Forgetting that print() adds a newline by default and then getting unexpected line breaks.
• Using string concatenation with numbers instead of multiple arguments or an f-string.
• Printing an entire cloud SDK response, which can produce noisy output or expose sensitive fields.
• Sending errors to standard output instead of sys.stderr, making shell and CI redirection confusing.
• Using human-readable labels in output that another program expects to parse as JSON.
• Omitting flush=True when a long-running progress or heartbeat message must appear immediately.
• Using print() as the logging system for a production service instead of configuring logging.
• Logging passwords, tokens, authorization headers, or complete environment variables.

Escape sequences let you embed special or hard-to-type characters inside an ordinary quoted string, using a backslash followed by a code.

>>> print("a\nb")
a
b
>>> print("a\tb")
a    b
>>> print("say \"hi\"")
say "hi"

The full escape-character reference, including octal/hex codes, is covered in 9.3 Escape Characters.

Quick Interview Answer

“An escape sequence is a backslash followed by a code that represents a special character inside a string — \n for newline, \t for tab, \\ for a literal backslash, \'/\" for a quote that would otherwise end the string early.”

Common Mistakes

• Forgetting to escape a quote character that matches the string’s own delimiter, causing the string to end early and raise a SyntaxError.
• Confusing \n (a two-character escape sequence Python turns into one newline byte) with an actual line break typed into a triple-quoted string — both work, but they’re not the same mechanism.

A code block is any indented group of statements introduced by a colon-terminated header line. All four kinds below follow the exact same indentation rule from 4.4 Indentation.

if Blocks

if status == "active":
    print("Service is running")

Loop Blocks

for server in ["web01", "web02"]:
    print(f"Checking {server}")

Function Blocks

def is_valid(code):
    return 200 <= code < 300

Class Blocks

class Server:
    def __init__(self, name):
        self.name = name

Quick Interview Answer

“A code block is any colon-terminated header line followed by an indented body — if, for/while, def, and class all use the exact same mechanism. There’s no separate ‘block’ keyword in Python; indentation alone marks where a block starts and ends.”

Common Mistakes

• Assuming each block type has different indentation rules — they don’t; if, loops, functions, and classes all follow the identical colon + indent pattern.
• Forgetting a return inside a function block and getting None back instead of the expected value.

Three ways Python’s line-based syntax can be bent — combining lines together, or splitting one statement across several lines.

Semicolon

What Is It?

Separates multiple simple statements placed on one physical line.

Why Is It Rarely Used?

Rarely used by convention (see 4.16 Coding Standards (PEP 8)), but valid syntax.

>>> a = 1; b = 2; print(a + b)
3

Backslash

What Is It?

An explicit line-continuation marker: the backslash at the end of a line tells Python “this statement isn’t finished yet, keep reading the next line.”

total = 1 + \
        2 + \
        3
>>> total
6

Implicit Continuation

What Is It?

Inside any open bracket — (), [], or {} — Python automatically treats newlines as continuations, no backslash needed.

Why Is It Preferred?

It’s visually cleaner and less error-prone than backslashes (a trailing space after a backslash silently breaks it).

nums = (1 +
        2 +
        3)
>>> nums
6

Quick Interview Answer

“Python offers three ways to bend its one-statement-per-line rule: semicolons combine statements onto one line (rarely used), a trailing backslash explicitly continues a statement onto the next line, and any open bracket — (), [], {} — implicitly continues across lines with no backslash needed. Implicit continuation inside brackets is the preferred style since a stray trailing space silently breaks a backslash continuation.”

Common Mistakes

• Leaving a trailing space after a line-continuation backslash — it silently breaks the continuation and raises a SyntaxError on the next line.
• Reaching for backslash continuation when the expression is already inside brackets, where implicit continuation would work without the backslash at all.

PEP 8 is Python’s official style guide. This section covers it from the syntax angle — the specific formatting rules that affect how code is laid out on the page.

Indentation

4 spaces per indentation level; never mix tabs and spaces (mixing raises a TabError in Python 3).

Line Length

Limit lines to 79 characters (or up to 99 by some team conventions) — keeps code readable side-by-side in diffs and split editor panes.

Naming

snake_case for variables/functions, PascalCase for classes, UPPER_SNAKE_CASE for constants — the same table introduced in Introduction to Python.

Imports

One import per line, grouped in order: standard library, then third-party packages, then local application imports — with a blank line between each group.

import os
import sys

import boto3

from myapp.utils import helper

Whitespace

Use a single space around operators and after commas; avoid extra spaces right inside brackets or right before a function call’s parentheses.

# PEP 8 compliant
total = price * quantity
func(a, b, c)

# Not PEP 8 compliant
total = price*quantity
func( a,b,c )

Quick Interview Answer

“PEP 8 is Python’s official style guide — 4-space indentation, a 79-character line limit, snake_case/PascalCase/UPPER_SNAKE_CASE naming by identifier type, imports grouped stdlib → third-party → local with one per line, and consistent spacing around operators. Tools like black or flake8 enforce most of it automatically, so it’s rarely a manual judgment call on a real team.”

Common Mistakes

• Mixing import groups together instead of ordering standard library, then third-party, then local application imports.
• Inconsistent spacing around operators (price*quantity vs price * quantity) that a formatter like black would catch automatically.
• Treating PEP 8 as optional style preference rather than the shared convention that keeps a team’s codebase consistently readable.

Five error types that account for the vast majority of syntax mistakes, especially for beginners — knowing what each one means makes them far faster to fix.

IndentationError

What Does It Mean?

A block is expected but the indentation is missing or inconsistent.

>>> if True:
... print("bad")
IndentationError: expected an indented block after 'if' statement on line 1

SyntaxError

What Does It Mean?

The general-purpose error for code that doesn’t match Python’s grammar at all — often a missing colon, unmatched bracket, or invalid character sequence.

>>> if True
  File "<stdin>", line 1
    if True
           ^
SyntaxError: expected ':'

NameError

What Does It Mean?

Technically a runtime error, not a syntax error — the code IS valid Python, but references a name that was never defined (often a typo).

>>> print(undefined_var)
Traceback (most recent call last):
NameError: name 'undefined_var' is not defined

Missing Colon

Why Does It Happen?

The single most common syntax mistake for beginners coming from other languages — every compound statement header (if/for/while/def/class) must end in :.

>>> def greet(name)
  File "<stdin>", line 1
    def greet(name)
                   ^
SyntaxError: expected ':'

Unmatched Brackets

What Does It Mean?

An opening (, [, or { without its matching close — Python reports exactly which bracket was never closed.

>>> x = [1, 2, 3
  File "<stdin>", line 1
    x = [1, 2, 3
        ^
SyntaxError: '[' was never closed

Quick Interview Answer

“IndentationError means a block’s indentation is missing or inconsistent. SyntaxError is the general grammar violation — most often a missing colon or an unmatched bracket. NameError is different from both: it’s a runtime error, meaning the code is syntactically valid but references a name that was never defined.”

Common Mistakes

• Confusing NameError (valid syntax, undefined name, caught only at runtime) with SyntaxError (invalid grammar, caught before anything runs).
• Not reading the caret (^) in the traceback — it points to exactly where the parser gave up, which is usually the fastest way to find the actual problem.

Seeing correct syntax structure in realistic scripts reinforces the rules covered across this chapter better than isolated snippets — here’s how the pieces come together in practice.

Configuration Scripts

A typical config module: constants at the top, dictionary literal for structured settings — direct application of 4.9 Constants and 4.10 Literals.

# config.py
MAX_RETRIES = 3
TIMEOUT_SECONDS = 30

DATABASE = {
    "host": "localhost",
    "port": 5432,
    "name": "prod_db",
}

Automation Scripts

A file-cleanup script showing imports, a function block, and the entry-point guard together — the full layout from 4.2 Structure of a Python Program in action.

import os

def remove_old_logs(folder, days=7):
    for filename in os.listdir(folder):
        print(f"Checking {filename}")

if __name__ == "__main__":
    remove_old_logs("/var/log/app")

Log Processing Script Structure

A minimal but complete log-scanning script — notice the consistent indentation nesting a for loop inside a with block.

def count_errors(log_path):
    error_count = 0
    with open(log_path) as f:
        for line in f:
            if "ERROR" in line:
                error_count += 1
    return error_count

AWS Script Layout

A boto3-based script following the same import → constants → function → entry-point pattern used throughout this chapter.

import boto3

REGION = "us-east-1"

def list_running_instances():
    ec2 = boto3.client("ec2", region_name=REGION)
    return ec2.describe_instances()

if __name__ == "__main__":
    list_running_instances()