def greet_user(username):
    """Display a personalized greeting."""
    print(f"Hello, {username.title()}!")

greet_user('jesse')
greet_user('sarah')

Hello, Jesse!
Hello, Sarah!

def describe_pet(animal_type, pet_name):
    """Display information about a pet."""
    print(f"I have a {animal_type}. Name: {pet_name.title()}.")

describe_pet('hamster', 'harry')
describe_pet('dog', 'willie')
describe_pet('cat', 'lucy')

I have a hamster. Name: Harry.
I have a dog. Name: Willie.
I have a cat. Name: Lucy.

def describe_pet(animal_type, pet_name):
    """Display information about a pet."""
    print(f"I have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name.title()}.")

describe_pet(animal_type='hamster', pet_name='harry')
describe_pet(pet_name='harry', animal_type='hamster')

I have a hamster.
My hamster's name is Harry.
I have a hamster.
My hamster's name is Harry.

def describe_pet(pet_name, animal_type='dog'):
    """Display pet information with a default animal type."""
    print(f"I have a {animal_type}. Name: {pet_name.title()}.")

describe_pet(pet_name='willie')
describe_pet('willie')
describe_pet(pet_name='harry', animal_type='hamster')

I have a dog. Name: Willie.
I have a dog. Name: Willie.
I have a hamster. Name: Harry.

def describe_pet(pet_name, animal_type='dog'):
    """Summarize pet attributes."""
    return f"{animal_type}: {pet_name.title()}"

print(describe_pet('willie'))
print(describe_pet(pet_name='willie'))
print(describe_pet('harry', 'hamster'))
print(describe_pet(pet_name='harry', animal_type='hamster'))

dog: Willie
dog: Willie
hamster: Harry
hamster: Harry

def get_formatted_name(first_name, last_name, middle_name=''):
    """Return a formatted name with an optional middle component."""
    if middle_name:
        full_name = f"{first_name} {middle_name} {last_name}"
    else:
        full_name = f"{first_name} {last_name}"
    return full_name.title()

print(get_formatted_name('jimi', 'hendrix'))
print(get_formatted_name('john', 'hooker', 'lee'))

Jimi Hendrix
John Lee Hooker

def build_person(first_name, last_name, age=None):
    """Return a dictionary of information about a person."""
    person = {'first': first_name, 'last': last_name}
    if age is not None:
        person['age'] = age
    return person

musician_1 = build_person('jimi', 'hendrix')
musician_2 = build_person('jimi', 'hendrix', age=27)
print(musician_1)
print(musician_2)

{'first': 'jimi', 'last': 'hendrix'}
{'first': 'jimi', 'last': 'hendrix', 'age': 27}

def parse_network_socket(socket_address):
    """Split an IP:port address string into separate components."""
    ip_addr, port_str = socket_address.split(':')
    return ip_addr, int(port_str)

ip, port = parse_network_socket("192.168.1.100:8080")
result_tuple = parse_network_socket("10.0.0.1:22")
print(f"IP: {ip}, Port: {port}")
print(f"Packed return: {result_tuple} (Type: {type(result_tuple).__name__})")

IP: 192.168.1.100, Port: 8080
Packed return: ('10.0.0.1', 22) (Type: tuple)

def format_user_record(username, role):
    """Normalize and validate user privilege record."""
    return f"User '{username.lower()}' assigned role: {role.upper()}"

user_inputs = [("alice", "admin"), ("bob", "analyst"), ("quit", "")]
audit_log = []
for u_name, u_role in user_inputs:
    if u_name == 'quit':
        break
    record = format_user_record(u_name, u_role)
    audit_log.append(record)

for entry in audit_log:
    print(entry)

User 'alice' assigned role: ADMIN
User 'bob' assigned role: ANALYST

1. Determinism: the same input always produces the same output.
1.

1. Zero Side Effects: it does not change external data, does not directly modify its passed-in parameters, and does not perform I/O such as print() or writing to a file.
2.

def add(a, b):
    return a + b

# add(2, 3) always returns 5, without affecting any external data

total = 0

def add(a):
    global total
    total += a
    return total

# Calling add(2) repeatedly returns 2, 4, 6... because the function modifies the external variable total

import re

def sanitize_identifier(raw_input):
    """Enforce strict alphanumeric whitelist on system identifiers."""
    cleaned = re.sub(r'[^a-zA-Z0-9_-]', '', raw_input.strip())
    if not cleaned:
        raise ValueError("Invalid identifier: contains no valid alphanumeric characters.")
    return cleaned.lower()

test_inputs = ["admin_user", "guest; DROP TABLE users;--", "SOC-analyst_01"]
for item in test_inputs:
    sanitized = sanitize_identifier(item)
    print(f"Raw: '{item}' -> Sanitized: '{sanitized}'")

Raw: 'admin_user' -> Sanitized: 'admin_user'
Raw: 'guest; DROP TABLE users;--' -> Sanitized: 'guestdroptableusers--'
Raw: 'SOC-analyst_01' -> Sanitized: 'soc-analyst_01'

import hashlib

def compute_sha256(data_string):
    """Compute hex-encoded SHA-256 digest of an input string."""
    encoded_bytes = data_string.encode('utf-8')
    hasher = hashlib.sha256(encoded_bytes)
    return hasher.hexdigest()

test_payload = "password123"
digest = compute_sha256(test_payload)
print(f"Payload: {test_payload}")
print(f"SHA-256: {digest}")

Payload: password123
SHA-256: ef92b778bafe771e89245b89ecbc08a44a4e166c06659911881f383d4473e94f

def add_user(names):
    names.append("alice")

usernames = ["hannah", "ty"]
add_user(usernames)

print(usernames)
# ['hannah', 'ty', 'alice']

['hannah', 'ty', 'alice']

def print_models(unprinted_designs, completed_models):
    """Simulate printing designs until none are left, moving to completed."""
    while unprinted_designs:
        current_design = unprinted_designs.pop()
        completed_models.append(current_design)

unprinted = ['phone case', 'robot pendant', 'dodecahedron']
completed = []
print_models(unprinted, completed)
print(f"Remaining in queue: {unprinted}")
print(f"Completed models: {completed}")

Remaining in queue: []
Completed models: ['dodecahedron', 'robot pendant', 'phone case']

• The slice syntax list_name[:] produces a shallow copy of the entire list.

def process_queue(work_list):
    """Consume elements from a queue."""
    while work_list:
        item = work_list.pop()
        print(f"Processed: {item}")

original_queue = ['task_alpha', 'task_beta', 'task_gamma']
process_queue(original_queue[:])
print(f"Original queue preserved: {original_queue}")

Processed: task_gamma
Processed: task_beta
Processed: task_alpha
Original queue preserved: ['task_alpha', 'task_beta', 'task_gamma']

def process_queue(work_list):
    while work_list:
        item = work_list.pop()
        print(f"Processed: {item}")

original_queue = ['task_alpha', 'task_beta', 'task_gamma']
process_queue(original_queue)  # No [:] used
print(f"Original queue: {original_queue}")

Processed: task_gamma
Processed: task_beta
Processed: task_alpha
Original queue: []

# Anti-pattern (shared accumulator):
def append_event_bug(event, log=[]):
    log.append(event)
    return log

# Defensive idiomatic fix:
def append_event_fixed(event, log=None):
    if log is None:
        log = []
    log.append(event)
    return log

print("Buggy calls:", append_event_bug("login"), append_event_bug("logout"))
print("Fixed calls:", append_event_fixed("login"), append_event_fixed("logout"))

Buggy calls: ['login', 'logout'] ['login', 'logout']
Fixed calls: ['login'] ['logout']

def make_pizza(*toppings):
    """Print the list of toppings that have been requested."""
    print(f"Packed tuple: {toppings} (Count: {len(toppings)})")
    for topping in toppings:
        print(f"- {topping}")

make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

Packed tuple: ('pepperoni',) (Count: 1)
- pepperoni
Packed tuple: ('mushrooms', 'green peppers', 'extra cheese') (Count: 3)
- mushrooms
- green peppers
- extra cheese

def change(x):
    x = x + 10

a = 5
change(a)
print(a)  # 5

#include <iostream>
using namespace std;

void change(int x) {
    x = x + 10;
    cout << x << endl;
}

int main() {
    int a = 5;
    change(a);
    cout << a; // 5
    return 0;
}

• Python: x initially references the object 5, then x is rebound to a new object 15. The variable a is unaffected.

• C++: x receives a copy of a's value, so changing x does not affect a.

#include <iostream>
#include <string>
using namespace std;

void change(int *x) {
    *x = *x + 10;
    cout << *x << endl;     // 15
}

void change(string *s) {
    *s += " World";
    cout << *s << endl;     // Hello World
}

int main() {
    int a = 5;
    change(&a);
    cout << a << endl;      // 15

    string name = "Hello";
    change(&name);
    cout << name << endl;   // Hello World
    return 0;
}

def change(x):
    x = x + 10   # int is immutable → new object, x is rebound

a = 5
change(a)
print(a)  # 5
print(id(a))  # object identity, not a pointer

• &a passes the address of a; *x dereferences the pointer to reach the original value.

• The pointer itself is passed by value (a copy of the address), but both copies point to the same variable.

• Python has no pointer arithmetic or dereferencing: names are bound to objects, and the model is object reference.

• Python note: int and str are immutable, so the caller's value can't be changed by reassigning the parameter; mutable objects (list, dict) can be changed in place.

def inspect_packet_queue(raw_packets, suspicious_alerts):
    """Analyze raw packet port headers and quarantine suspicious traffic."""
    while raw_packets:
        pkt = raw_packets.pop(0)
        port = pkt.get('port', 0)
        # Flag well-known insecure legacy cleartext protocols: Telnet(23), HTTP(80)
        if port in (23, 80):
            suspicious_alerts.append(f"FLAGGED: Insecure port {port} from {pkt.get('src')}")

traffic_stream = [
    {'src': '10.0.0.5', 'port': 443},
    {'src': '192.168.1.50', 'port': 23},
    {'src': '172.16.0.12', 'port': 80}
]
alerts = []
inspect_packet_queue(traffic_stream, alerts)
for alert in alerts:
    print(alert)

FLAGGED: Insecure port 23 from 192.168.1.50
FLAGGED: Insecure port 80 from 172.16.0.12

def make_pizza(size, *toppings):
    """Summarize the pizza we are about to make."""
    print(f"Making a {size}-inch pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

Making a 16-inch pizza with the following toppings:
- pepperoni
Making a 12-inch pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese

def build_profile(first, last, **user_info):
    """Build a dictionary containing everything we know about a user."""
    user_info['first_name'] = first
    user_info['last_name'] = last
    return user_info

user_profile = build_profile(
    'albert', 'einstein',
    location='princeton',
    field='physics'
)
print(user_profile)

{'location': 'princeton', 'field': 'physics', 'first_name': 'albert', 'last_name': 'einstein'}

1. Standard positional-or-keyword parameters (without defaults)
1.

1. Positional parameters with default values
2.

1. Arbitrary positional arguments (*args)
3.

1. Keyword-only parameters (with or without defaults)
4.

1. Arbitrary keyword arguments (**kwargs)
5.

def configure_firewall(rule_id, interface='eth0', *ports, log=True, **metadata):
    """Demonstrate full parameter spectrum."""
    return {
        'id': rule_id,
        'iface': interface,
        'ports': ports,
        'log': log,
        'meta': metadata
    }

config = configure_firewall(101, 'eth1', 80, 443, 8080, log=False, author='sec_ops', zone='dmz')
print(config)

{'id': 101, 'iface': 'eth1', 'ports': (80, 443, 8080), 'log': False, 'meta': {'author': 'sec_ops', 'zone': 'dmz'}}

def scan_target(host, port, timeout):
    """Simulate scanning a specific host and port."""
    return f"Scanning {host}:{port} (timeout={timeout}s)"

target_list = ["192.168.1.1", 443, 5]
target_dict = {"host": "10.0.0.1", "port": 22, "timeout": 2}

print("Unpacked list: ", scan_target(*target_list))
print("Unpacked dict: ", scan_target(**target_dict))

Unpacked list:  Scanning 192.168.1.1:443 (timeout=5s)
Unpacked dict:  Scanning 10.0.0.1:22 (timeout=2s)

def audit_host(ip_address, *target_ports, **options):
    """Simulate multi-port security probe with dynamic options."""
    verbose = options.get('verbose', False)
    protocol = options.get('protocol', 'TCP')
    results = []
    for port in target_ports:
        status = "OPEN" if port in (80, 443, 22) else "FILTERED"
        if verbose:
            results.append(f"[{protocol}] {ip_address}:{port} -> {status}")
        else:
            results.append(f"{port}:{status}")
    return results

scan_summary = audit_host('192.168.1.254', 21, 22, 80, protocol='TCP', verbose=True)
for item in scan_summary:
    print(item)

[TCP] 192.168.1.254:21 -> FILTERED
[TCP] 192.168.1.254:22 -> OPEN
[TCP] 192.168.1.254:80 -> OPEN

• Can accept any number of arguments (comma-separated).

• Can only contain a single expression whose evaluated result is automatically returned.

• Cannot contain statements, loops, assignments, or multiline logic.

# Standard function:
def double_standard(x):
    return x * 2

# Equivalent lambda expression:
double_lambda = lambda x: x * 2

print("Standard function call:", double_standard(5))
print("Lambda function call:  ", double_lambda(5))

Standard function call: 10
Lambda function call:  10

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Filter even numbers:
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

# Security application: filter high privileged ports (< 1024):
ports = [21, 22, 80, 443, 8080, 8443, 9000]
privileged_ports = list(filter(lambda p: p < 1024, ports))

print(f"Even numbers: {even_numbers}")
print(f"Privileged ports: {privileged_ports}")

Even numbers: [2, 4, 6, 8, 10]
Privileged ports: [21, 22, 80, 443]

numbers = [1, 2, 3, 4, 5]

# Calculate cubes:
cubes = list(map(lambda x: pow(x, 3), numbers))

# Security application: sanitize IP list into subnet broadcast targets:
host_suffixes = [10, 20, 30, 40]
ip_targets = list(map(lambda host: f"192.168.1.{host}", host_suffixes))

print(f"Cubes: {cubes}")
print(f"IP targets: {ip_targets}")

Cubes: [1, 8, 27, 64, 125]
IP targets: ['192.168.1.10', '192.168.1.20', '192.168.1.30', '192.168.1.40']

# List of tuples: (Service, Port, Risk Score)
services = [("HTTP", 80, 8.5), ("SSH", 22, 4.2), ("FTP", 21, 9.8), ("HTTPS", 443, 2.1)]

# Sort by Port number (index 1):
by_port = sorted(services, key=lambda s: s[1])

# Sort by Risk Score descending (index 2):
by_risk = sorted(services, key=lambda s: s[2], reverse=True)

print("Sorted by Port: ", by_port)
print("Sorted by Risk: ", by_risk)

Sorted by Port:  [('FTP', 21, 9.8), ('SSH', 22, 4.2), ('HTTP', 80, 8.5), ('HTTPS', 443, 2.1)]
Sorted by Risk:  [('FTP', 21, 9.8), ('HTTP', 80, 8.5), ('SSH', 22, 4.2), ('HTTPS', 443, 2.1)]

# Conceptual pure-Python demonstration of DataFrame column transformation:
dataset = [
    {'name': 'Luke', 'birthyear': 1976},
    {'name': 'Gina', 'birthyear': 1984},
    {'name': 'Sam',  'birthyear': 2008},
    {'name': 'Emma', 'birthyear': 2012}
]

CURRENT_YEAR = 2026

# Transform records using lambda projection:
for row in dataset:
    row['age'] = (lambda yr: CURRENT_YEAR - yr)(row['birthyear'])

# Filter adult accounts:
adults = list(filter(lambda r: r['age'] >= 18, dataset))
for adult in adults:
    print(f"Name: {adult['name']}, Age: {adult['age']}")

Name: Luke, Age: 50
Name: Gina, Age: 42

• df['age'] = df['birthyear'].apply(lambda x: CURRENT_YEAR - x)

• df[df['age'] >= 18]

events = [
    {"src": "10.0.0.12",    "event": "Failed SSH",           "severity": 2},
    {"src": "192.168.1.99", "event": "SQL Injection attempt", "severity": 5},
    {"src": "10.0.0.15",    "event": "Port sweep",            "severity": 3},
    {"src": "172.16.0.4",   "event": "Privilege escalation",  "severity": 5}
]

# 1. Filter critical events (severity >= 4):
critical_alerts = list(filter(lambda e: e["severity"] >= 4, events))

# 2. Sort critical alerts by IP source address:
critical_alerts.sort(key=lambda e: e["src"])

for alert in critical_alerts:
    print(f"[SEV {alert['severity']}] {alert['src']}: {alert['event']}")

[SEV 5] 172.16.0.4: Privilege escalation
[SEV 5] 192.168.1.99: SQL Injection attempt

# File: pizza.py
def make_pizza(size, *toppings):
    print(f"Making a {size}-inch pizza with toppings: {', '.join(toppings)}")

# File: making_pizzas.py
import pizza

pizza.make_pizza(16, 'pepperoni')
pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

Making a 16-inch pizza with toppings: pepperoni
Making a 12-inch pizza with toppings: mushrooms, green peppers, extra cheese

# File: making_pizzas.py
from pizza import make_pizza

make_pizza(16, 'pepperoni')

Making a 16-inch pizza with toppings: pepperoni

# File: crypto_utils.py
def generate_nonce():
    import secrets
    return secrets.token_hex(16)

# Execution guard block:
if __name__ == '__main__':
    # Unit tests / CLI demo executed ONLY when run directly:
    sample_nonce = generate_nonce()
    print(f"[Self-Test] Generated 16-byte nonce: {sample_nonce}")

[Self-Test] Generated 16-byte nonce: 8f4a13d7e6c9b201a4f89d3e7b1c504a

1. Naming: Function names must be lowercase with words separated by underscores (snake_case) to improve readability.
1.

1. Docstrings: Every function definition should immediately be followed by a docstring ("""Docstring""") describing its purpose, parameters, and return value.
2.

1. Default parameters: Do not place spaces around the = sign when specifying a default parameter value (def func(port=80):).
3.

1. Modern Type Annotations (PEP 484 / Python 3.9+):
4.

def validate_port(port: int, allow_privileged: bool = False) -> bool:
    """Validate whether a port integer falls within permissible policy limits."""
    if not (1 <= port <= 65535):
        return False
    if not allow_privileged and port < 1024:
        return False
    return True

print("Port 443 (default): ",          validate_port(443))
print("Port 443 (privileged allowed): ", validate_port(443, allow_privileged=True))
print("Port 8080: ",                    validate_port(8080))

Port 443 (default):           False
Port 443 (privileged allowed): True
Port 8080:                    True