Variables, Loops, Functions

A variable is a name bound to a value. host = "127.0.0.1" is a str — text, even when it looks like an address. port = 22 is an int — arithmetic and comparisons work; "22" as a string would not sort or increment the way you think. timeout = 1.0 is a float you are not using yet; is_lab = True is a bool for a guard you should keep. Python does not make you declare types up front, which is speed of writing; it also will not stop you from concatenating a string to an int and exploding at runtime. For security scripts, name the type in the name or in a comment until it is muscle: target_host, port_number, line_text. Future you is on-call.

A list is an ordered collection: ports = [22, 80, 443] or lines you will load from a file next lesson. Lists are how “one” becomes “many” without twenty variables named port1, port2, port3. Indexing starts at 0; you rarely need indexes when a for loop gives you the item. Mixing types in one list (22, "http", None) is legal and almost always a future bug in a parser. Keep port lists as ints. Keep log lines as str. Convert on the boundary with int() or str() when you must, and fail loudly if the conversion is nonsense — a lab file you wrote should not contain surprise types, but production logs will.

for item in collection: repeats an indented block once per element. for port in ports: print("Lab list only:", port) is the entire mechanism of a later checker, minus the dangerous part. The colon opens a block; indentation is the block. Forget the indent and Python SyntaxError’s you; mix tabs and spaces and you get a fight. The loop variable is just a name: port, line, url. Each pass rebinds it. After the loop, it still holds the last value — do not rely on that as a feature. while condition: exists for “until a flag”; for security beginners, for-each over a list you already have is the safer default because it cannot spin forever unless the list is huge.

Conceptually you will loop log lines the same way: for line in f: if needle in line. The file object is iterable; you do not load a gigabyte into RAM to hunt a substring. That pattern is the next lesson. This lesson’s port list is fiction you typed: common service numbers as data, not a promise that those services are running, not a SYN to a stranger. If you add socket.create_connection inside the loop “to see,” you changed the lesson into a scan. Do not. Printing teaches iteration. Connecting needs permission, a timeout, and a target you own — Module 2.

def banner(name): starts a function. The indented body runs only when you call banner("lab-target"). return hands a value back; without return, the function yields None. Parameters are local names: the caller’s variable is not rewritten unless you mutate a list in place (avoid that until you mean it). A function is a contract: inputs in, result or side effect out, name that tells the truth. label_host(host: str) -> str that returns f"[lab] host={host}" is reviewable. x(a) that sometimes prints and sometimes connects is how accidental scans happen when someone reuses a helper.

Copy-paste fails on a delay. You duplicate a five-line check for port 22, then 80, then 443. Next week you add a timeout to the first copy and forget the others. A reviewer cannot see the difference in a diff full of clones. A bug in the pasted block is now N bugs. The fix is not “be more careful.” The fix is one function and one loop: for port in ports: print(label_port(port)). When the label format changes, you change one return. When the list grows, you append a number — you do not clone a function. That is the same reason Lesson 1 preferred readable scripts: the unit of review is a named behavior, not a wallpaper of near-duplicates.

target_host beats x. failed_logins beats data2. ports_lab_only beats stuff. Honest names are how a teammate sees that this list is not a live inventory. A small main() that only prints, behind if __name__ == "__main__":, keeps import from running the loop as a side effect later. You do not need that guard to pass this lesson, but you should know it exists so a future import of your helper does not spray stdout — or worse, connect. Comments that say “NO SOCKET YET” are not cute; they are a scope comment a tired you will obey. Put the script under $HOME/cyberlium-lab. chmod 600 if the file might later grow hostnames or findings you do not want a shared Windows account to read.

Write ports_lab.py in the lab directory. The list is teaching data: 22, 80, 443 as numbers people recognize, not a scan plan. The function returns a string; the loop prints it. Confirm python/python3 still runs. If you want a second loop, iterate a tiny list of fictional log-line strings you typed in the same file — still print, still your data. Do not import socket in this file. Do not read /etc/passwd to “make a user list.”

mkdir -p "$HOME/cyberlium-lab"
cd "$HOME/cyberlium-lab"

cat > ports_lab.py << 'EOF'
from pathlib import Path

lab = Path.home() / "cyberlium-lab"
lab.mkdir(parents=True, exist_ok=True)

host = "127.0.0.1"  # str — identity of MY loopback, not a target list
timeout_seconds = 1.0  # unused on purpose: no connect in this lesson
is_lab = True
ports = [22, 80, 443]  # ints in a list — fictional service numbers
sample_lines = [
    "sshd: Failed password for labuser from 10.0.0.5 (FICTIONAL)",
    "sshd: Accepted password for alice from 10.0.0.9 (FICTIONAL)",
]


def label_port(port: int) -> str:
    return f"[lab-list-only] would_check host={host} port={port} live_scan=NO"


def label_line(line: str) -> str:
    return f"[lab-line] {line}"


def main() -> None:
    if not is_lab:
        raise SystemExit("refusing to run: is_lab is False")
    print("types:", type(host).__name__, type(ports[0]).__name__, type(ports).__name__)
    for port in ports:
        print(label_port(port))
    needle = "Failed password"
    for line in sample_lines:
        if needle in line:
            print(label_line(line))
    # NEVER: socket.create_connection((host, port))
    # NEVER: copy-paste label_port twenty times


if __name__ == "__main__":
    main()
EOF

python ports_lab.py || python3 ports_lab.py
chmod 600 "$HOME/cyberlium-lab/ports_lab.py"

You can store str, int, and list, iterate with for, and reuse logic with def so the twentieth port is an append not a clone. Printing a fictional list is still not a scan. Next — File Handling — you will replace the tiny sample_lines list with with open() and pathlib on logs and practice wordlists you wrote yourself, only under $HOME/cyberlium-lab, never /etc/shadow or anyone else’s files.