Getting Started with Python

Python is commonly classified as an interpreted language, but behind the scenes, modern CPython (the standard reference implementation written in C) employs a hybrid compilation-interpretation pipeline:

1. Lexing & Parsing: When a Python program (`script.py`) is executed, the interpreter's tokenizer converts source text into a stream of lexical tokens. The parser then validates grammatical syntax against Python's formal grammar, generating an Abstract Syntax Tree (AST).
2. Bytecode Compilation: If syntax is valid, the compiler translates the AST into an intermediate, platform-independent representation called Python Bytecode. Bytecode instructions are low-level numeric opcodes optimized for virtual execution. Bytecode is cached on disk inside the `pycache` directory as `.pyc` files to accelerate future execution startup.
3. Python Virtual Machine (PVM): The PVM is the runtime software engine of Python. It contains an execution loop that reads bytecode instructions one by one, maps them to native machine code instructions, and directs the underlying CPU to execute them.

Execution Modes

• Interactive Mode (REPL): Launched by typing `python` in a terminal. Provides an immediate Read-Eval-Print Loop denoted by the primary prompt `>>>`. Excellent for rapid prototyping, syntax experimentation, and one-line evaluations. Code is executed immediately and not saved to disk.
• Script Mode: Source code is authored in a plain text file saved with a `.py` extension (e.g., `main.py`). The entire script is executed from top to bottom via `python main.py`. Required for multi-line modular programming, functions, and persistent production software.

Every character sequence in a Python script is parsed into one of five fundamental Tokens:

A. Keywords

Reserved words with predefined, immutable grammatical meanings to the compiler. Python 3 contains 35 keywords (all lowercase except `False`, `None`, and `True`):

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

B. Identifiers

User-defined names assigned to variables, functions, classes, and modules. Identifier Rules:

• Must begin with an alphabet letter ($A-Z, a-z$) or an underscore (`_`).
• Subsequent characters can include letters, underscores, or digits ($0-9$).
• Cannot begin with a digit (e.g., `2count` is illegal; `count2` is legal).
• Python is strictly case-sensitive (`Total`, `total`, and `TOTAL` are three distinct identifiers).
• Cannot use special punctuation characters or whitespace (`@`, `$`, `%`, `-`, `.` are prohibited).
• Cannot be a reserved keyword (e.g., `def = 10` causes a `SyntaxError`).

C. Literals (Constant Data Values)

• Integer: Unbounded arbitrary-precision integers (e.g., `42`, `-100`, `0b1010` [binary], `0o77` [octal], `0xFF` [hex]).
• Floating-Point: Real numbers with decimal points or scientific exponential notation (`3.14159`, `-0.005`, `2.5e-3` $= 2.5 \times 10^{-3}$).
• Complex Numbers: Real and imaginary parts: $z = a + bj$ where $j = \sqrt{-1}$ (e.g., `z = 3 + 4j`; access via `z.real` and `z.imag`).
• Boolean: Truth values `True` (evaluates to numeric 1) and `False` (evaluates to numeric 0).
• String Literals: Text enclosed in single (`'...'`), double (`"..."`), or triple quotes (`'''...'''` or `"""..."""` for multi-line strings).
• Special Literal: `None` represents the absence of a value or null state.

In languages like C or C++, a variable is a named physical memory box with a fixed type: `int x = 10;`. The box `x` can only ever hold integers.

In Python, everything is an object, and variables are names (references/tags) bound to objects in heap memory:

x = 10       # 1. Integer object 10 created in heap memory.
             # 2. Variable name 'x' is bound (points) to this object.
print(id(x)) # Outputs the unique 64-bit memory address of object 10.
print(type(x)) # <class 'int'>

x = "Hello"  # 3. String object "Hello" created.
             # 4. 'x' is rebound to "Hello". Object 10 is dereferenced.
print(type(x)) # <class 'str'> (Dynamic Typing in action!)

Automatic Garbage Collection

Python tracks the number of references pointing to every heap object via Reference Counting. When an object's reference count drops to zero (no variable names point to it), Python's automatic Garbage Collector immediately reclaims that memory block.

Every Python object is classified as either Mutable or Immutable based on whether its in-place memory state can be modified after creation:

Proof of Immutability vs Mutability in Python:

# Immutable Example (Integer):
a = 5
old_id = id(a)
a = a + 1
print(id(a) == old_id) # False! New object 6 created; 'a' points to new ID.

# Mutable Example (List):
lst = [1, 2, 3]
old_id = id(lst)
lst.append(4)
print(id(lst) == old_id) # True! Same memory block modified in-place!

A. Standard Input (`input()`)

The `input([prompt])` function reads a line of text from standard input (keyboard) and strictly returns it as a string (`str`). To perform arithmetic, explicit type casting is mandatory:

# WRONG (String concatenation trap):
a = input("Enter a: ") # User inputs 5 -> a = "5"
b = input("Enter b: ") # User inputs 10 -> b = "10"
print(a + b)           # Prints "510" (String concatenation!)

# CORRECT (Explicit Type Casting):
a = int(input("Enter a: ")) # Casts "5" -> 5
b = int(input("Enter b: ")) # Casts "10" -> 10
print(a + b)                # Prints 15 (Arithmetic addition!)

B. Standard Output (`print()`)

The `print()` function accepts variable arguments along with two critical keyword formatting parameters:

• `sep`: The string inserted between multiple values. Default is a single space (`sep=' '`).
• `end`: The string appended at the very end of the output. Default is a newline (`end='\n'`).

print("2026", "09", "08", sep="-") # Prints: 2026-09-08
print("Loading", end="...")
print("Done")                       # Prints: Loading...Done (on same line!)