Getting Started with Python: A Gentle, Practical Introduction

Python (as a language)

A programming language used to give instructions to computers. Known for being readable, beginner-friendly, and powerful.

Python 3

The current standard version of Python. Actively maintained and recommended for all new projects and for learning.

Python 2 end-of-life

Python 2 stopped receiving updates in January 2020. New learners should not use it and should choose Python 3 instead.

Interpreter

A program that reads your Python code line by line, translates it into lower-level operations, and executes it.

Script mode

Running Python code saved in a .py file, for example using a command like `python my_script.py`.

Interactive mode

Typing Python commands one line at a time (for example in a Python shell or notebook) and seeing results immediately.

Python REPL

The interactive Python shell where you type commands at `>>>` and see results immediately. REPL stands for Read–Evaluate–Print Loop.

Script file

A saved text file ending in `.py` that contains Python code. You run the whole file at once using Python.

Official Python download site

The safe, up-to-date place to get Python: `https://www.python.org`. Avoid random download sites.

PATH (on Windows)

A system setting that lets you run `python` from any Command Prompt. Checking 'Add python.exe to PATH' during install sets this up.

Interactive mode vs script

Interactive mode is like a scratchpad for quick tests. A script is a saved program you can run again and share.

Variable

A named storage location in memory that holds a value, like `age = 15`. You can use the name later to access or change the value.

Assignment

The act of giving a value to a variable using `=`, for example `score = 10`.

int

Integer type in Python: whole numbers without a decimal point, such as `-3`, `0`, `42`.

float

Floating-point type in Python: numbers with a decimal point, such as `3.14`, `0.5`, `-2.0`.

str (string)

Text data type in Python, written inside quotes, for example `"Hello"` or `'Python'`.

bool (boolean)

Logical data type with only two values: `True` or `False`.

List

An ordered, mutable collection of items written with square brackets [], like [1, 2, 3]. You can change, add, and remove items.

Tuple

An ordered, immutable collection of items written with parentheses (), like (1, 2, 3). Once created, it cannot be changed.

Dictionary

A collection of key–value pairs written with curly braces {}, like {"name": "Aisha", "age": 15}. You access values by key, not by index.

Index

The position of an item in a list or tuple. The first item has index 0. Negative indexes like -1 start from the end.

append()

A list method that adds a new item to the end of a list, for example: my_list.append("new").

insert()

A list method that adds a new item at a specific position: my_list.insert(index, item). Existing items move to the right.

Condition

An expression that can be either True or False, such as `age >= 18` or `password == "abc"`.

If statement

A structure that runs a block of code only if its condition is True.

Elif

Short for else if. Used after an if to check another condition if previous ones were False.

Else

The block that runs if all previous if/elif conditions in the chain are False.

Indentation

Spaces at the start of a line that show which lines belong to a block, such as inside an if statement.

Comparison operators

Operators like `==`, `!=`, `<`, `>`, `<=`, `>=` that compare values and return True or False.

for loop

A loop that goes through each item in a sequence (like a range, list, or string) and runs the loop body once for each item.

while loop

A loop that repeats as long as its condition is true. Good when you do not know in advance how many times you will loop.

range(start, stop, step)

A function that produces a sequence of numbers for looping. Commonly used as range(start, stop). The sequence includes start but stops before stop.

break

A statement that immediately ends the nearest loop and jumps to the code after the loop.

continue

A statement that skips the rest of the current loop body and moves on to the next repetition of the loop.

Looping over a dictionary

Use `for key in d`, `for value in d.values()`, or `for key, value in d.items()` to process the keys and values in a dictionary.

Function

A named block of code that does one job. You define it once with `def` and call it whenever you need that job done.

Function definition

The part of the code where you create a function, starting with `def name():` and followed by an indented body.

Function call

Using a function by writing its name followed by parentheses, for example `greet("Mia")`.

Parameter

A variable name in the function definition that receives a value when the function is called.

Argument

The actual value you pass into a function when you call it, for example `"Mia"` in `greet("Mia")`.

Return value

The result that a function sends back using `return`. You can store it in a variable or use it in expressions.

input()

A function that pauses the program, shows a prompt, and returns what the user types as a string. You usually convert it to int or float for numbers.

print()

A function that sends information to the screen. Often used with f-strings to mix text and variable values in a clear way.

f-string

A string that starts with f and allows `{}` placeholders for expressions, for example: `f"Total: {total:.2f}"`.

with open(...) as f:

The safest pattern for working with files. It opens a file, gives you a file object `f`, and automatically closes the file when the block ends.

File modes: "r", "w", "a"

"r" = read, "w" = write (create/overwrite), "a" = append (add to the end). Used as the second argument to `open()`.

encoding="utf-8"

Tells Python to read or write text using UTF-8, the standard encoding on modern systems. Helps avoid weird character errors.

Module

A Python file that contains code (functions, classes, variables) that you can import and reuse in other programs.

Standard library

The collection of modules that comes built into Python (such as math, random, datetime, pathlib). You do not need pip to use them.

import module

An import style that brings in the whole module, so you use names with a prefix, like math.sqrt or random.randint.

from module import name

An import style that brings specific names from a module so you can use them directly, like from math import sqrt, pi.

pip

Python’s package manager. It installs third-party packages from the Python Package Index (PyPI) so you can import them.

pathlib

A standard library module for working with file and folder paths in a clean, cross-platform way using Path objects.

Syntax error

An error where Python cannot read the code at all because the "grammar" is wrong. Detected before the program starts running, usually shown as SyntaxError.

Runtime error (exception)

An error that happens while the program is running, even though the code is valid Python. Examples: ZeroDivisionError, ValueError, NameError.

Traceback

Python’s error report. It shows the file and line number where the error happened, the code line, and the error type with a short message.

Debugging

The process of finding and fixing problems (bugs) in your code. Often involves reading tracebacks, using print statements, and testing small pieces of code.

Print debugging

A simple debugging method where you add print statements to show variable values and program flow, helping you see what is really happening.

try/except block

Python structure used to handle expected errors. Code that might fail goes in try; the except block defines what to do if a specific error type occurs.

Breaking a problem into steps

Write out what your program should do in simple, human steps (like a recipe) before coding. Then match each step to Python tools such as input, loops, and conditionals.

Input / Processing / Output

Input: data from the user (with `input()`). Processing: calculations and decisions (variables, loops, `if`). Output: information shown to the user (with `print()`).

Function

A named block of code that does a specific job. Example: `def play_game():` defines a function you can call whenever you want to run the game.

Module

A separate file or built-in library with extra code you can reuse. You bring it in with `import`. Example: `import random` lets you use `random.randint()`.

Debugging

The process of finding and fixing errors in your code. Common tools: reading error messages, adding temporary `print()` statements, and testing edge cases.

Loop with `else`

In Python, a `for` or `while` loop can have an `else` block. The `else` runs only if the loop finishes normally (no `break`). In the game, it runs when the player uses all attempts.