Score: 0/20
20 Questions. Test your ability to manage the "Fuse Box" of Python. Green = Correct, Red = Incorrect.
BeginnerAnalogy
********The Fuse Box.
It "catches" the surge (Error) and handles it safely so the whole house (Program) doesn't burn down (Crash).
BeginnerTerminology
********Exception.
When an issue occurs during runtime (like division by zero), Python raises an "Exception".
ArchitectBest Practice
********Log errors immediately.
Architects ensure that when something breaks, it is reported clearly (Loudly) and immediately (Fast) to logs for debugging.
ArchitectAnti-Pattern
except:)?โ********It hides real bugs.
A bare except: catches everything, including things you didn't expect (like typos or SystemExit), making debugging impossible.
AdvancedKeywords
try``**finally``**else``**except``**else.
The "Success Party" block. It executes only if the try block completes successfully without raising an exception.
AdvancedKeywords
else``**finally``**always``**done``**finally.
The "Cleaning Crew". It runs whether an error occurred or not, perfect for closing files or database connections.
LabPort Scanner
ValueError``**TypeError``**ZeroDivisionError``**PortError``**ValueError.
int("Five") fails because the string "Five" cannot be converted to a base-10 integer.
LabPort Scanner
1000 / port, which Exception is raised?โValueError``**ArithmeticError``**ZeroDivisionError``**NullPointer``**ZeroDivisionError.
Math rules apply in Python. Dividing by zero is illegal and raises this specific exception.
ArchitectGraceful Degradation
********Continuing the main task.
If the logging server is down, the security scan should not crash. It should catch the error and finish the scan anyway.
TechnicalBubbling
********Moving up the stack.
If a function doesn't handle an error, it "bubbles up" to the function that called it, all the way to the top level.
SecurityLeakage
********Prevents info leaks.
Raw error messages (tracebacks) often reveal file paths or logic structure. Catching them allows you to show a sanitized message.
LimitationScope
try-except NOT handle?โ********Syntax Errors.
try-except only handles errors that happen during execution (Runtime). It cannot catch bad grammar (Syntax) because the code won't even parse.
Cheat SheetAnalogy
try block?โ********The Experiment.
This is the dangerous code you are attempting to run, which might explode (raise an error).
BenefitStability
********Prevents failure from minor issues.
You don't want the entire build to turn Red just because one non-critical API call timed out.
StructureExecution Flow
try, what happens to the remaining code inside try?โ********It is skipped.
Execution immediately jumps to the except block. The rest of the "Experiment" is abandoned.
Cheat SheetAnalogy
except block?โ********The Backup Plan.
If the experiment fails, you switch to Plan B (handle the error) instead of giving up.
SyntaxCatch-All
except:``**catch all:``**except Exception as e:``**except Error:``**except Exception as e:
This catches standard exceptions and gives you access to the error message (e), unlike a bare except: which is blind.
CoreLogic
********Keeping the program running.
Resilient code can handle shocks (errors) without collapsing completely.
LabExecution Path
********try -> except ZeroDivision -> finally.
The error is raised in try, caught by the specific ZeroDivisionError block, and then finally runs for cleanup.
BenefitReadability
********Separates logic.
Instead of cluttering your main logic with if error then... checks, you move all failure handling to the except blocks.
Your Final Score:
0/20 Novice
Keep practicing to reach Architect level!
**Objective: Create a script that takes a port number and checks if it's a "Reserved" port (1-1024).
Python
# Step 1: Capture Input
port_input = input("Enter the Port Number to scan: ")
# Step 2: Input Validation & Type Casting
try:
port = int(port_input) # Convert string to integer
if port <= 1024:
print(f"Warning: Port {port} is a Reserved System Port!")
else:
print(f"Port {port} is safe to use for your application.")
except ValueError:
print("Error: Please enter a valid numeric number, not text!")
Objective: Prevent unauthorized strings from entering your script logic.
Scenario: You are writing a script that triggers a security scan. The script should only proceed if the user enters "dev", "test", or "prod". If they enter anything else (like "hacker_env"), the script must stop.
The Task:
Use an "Allow-list" (a Python list of approved strings).
Clean the input using .lower() and .strip() to ensure " PROD " or "Prod" works correctly.
Check if the input is in the list.
Solution:
allowed_environments = ["dev", "test", "prod"]
# Capture and Clean
target_env = input("Enter Target Environment (dev/test/prod): ").strip().lower()
# Validate against Allow-list
if target_env in allowed_environments:
print(f"Validated! Starting security audit on [{target_env}]...")
else:
print(f"CRITICAL ERROR: Environment '{target_env}' is NOT authorized.")
Objective: Capture sensitive data (like API Keys or Passwords) without showing them on the screen.
Scenario: In DevSecOps, "Shoulder Surfing" is a risk. If you use standard input(), everyone can see the password as you type it. We need to hide it.
The Task:
Use the built-in getpass module.
Ensure the sensitive data is never printed back to the terminal.
Solution:
import getpass
user = input("Enter Admin Username: ")
# This hides the characters as you type
api_token = getpass.getpass("Enter your Secret API Token: ")
if api_token == "Secret123":
print(f"Access Granted. Welcome, {user}!")
else:
print("Authentication Failed!")
Objective: Convert an interactive script into a professional CLI tool for Jenkins/GitHub Actions.
Scenario: You have a script that requires an IP address and a Port. You want to pass these as Command Line Arguments so the script can run in an automated CI/CD pipeline without waiting for a human to type.
The Task:
Use the argparse library.
Define a required argument for the IP and an optional argument for the Port (default 80).
Solution:
import argparse
# 1. Initialize Parser
parser = argparse.ArgumentParser(description="DevSecOps Automated Scanner")
# 2. Add Arguments
parser.add_argument("--host", help="Target IP Address", required=True)
parser.add_argument("--port", type=int, default=80, help="Target Port (Default: 80)")
# 3. Parse and Access
args = parser.parse_args()
print(f"Automated Scan initiated for {args.host} on port {args.port}...")
python scanner.py --host 192.168.1.1 --port 443Score: 0/20
20 Questions. Capturing data, Security Gates, and Avoiding the Type Trap. Green = Correct, Red = Incorrect.
BeginnerAnalogy
input() function?โ********The Guard.
input() is the entity that pauses the flow and asks the visitor (user) for information.
BeginnerReturn Type
input() ALWAYS return by default?โ********String (str).
Even if the user types a number like 100, Python treats it as text "100" unless you cast it.
BeginnerSyntax
name = input("Enter Name: ")``**input(name, "Enter Name: ")``**print("Enter Name: ")``**get_input("Name")``**input("Message")
You pass the prompt string directly inside the input() function parentheses.
TrapType Trap
age = input("Age: ") and type 20, then age + 1?โ********TypeError.
You cannot add an Integer (1) to a String ("20"). You must convert age to an int first.
SolutionCasting
input(int("Age: "))``**input("Age: ").to_int()``**int(input("Age: "))``**input("Age: ", type=int)``**Wrap input() in int().
This explicitly converts the string returned by input into an integer immediately.
ArchitectInput Validation
********Security risks.
Architects must implement Input Validation. Raw input can crash a server or lead to security vulnerabilities if not sanitized.
ArchitectCI/CD
input() NOT suitable for CI/CD pipelines (like Jenkins)?โ********It blocks execution.
Since pipelines are automated, there is no human to type the answer. The job will hang indefinitely and fail.
ArchitectAutomation Tool
input()``**text_prompt``**argparse``**sys.input``**argparse.
For automated DevSecOps tools, we use Command Line Arguments via argparse so scripts run without human intervention.
AdvancedCLI Basics
sys.argv?โsys``**os``**cli``**cmd``**sys.
sys.argv provides a simple list of arguments passed to the script at runtime.
CoreBehavior
input()?โ********Program pauses.
Code execution stops at the input() line and waits for the user to provide data and hit Enter.
SyntaxFloat Input
input("Price: ", float)``**decimal(input("Price: "))``**float(input("Price: "))``**input_float("Price: ")``**float(input(...)).
Just like int(), you wrap the input function with float() to handle decimal numbers.
AdvancedMultiple Inputs
x, y = input().split()``**x, y = input()``**input().two_values()``**x = input(); y = input()``**.split().
split() breaks the string by spaces, allowing you to unpack multiple values into variables instantly.
AnalogyVisitor
********The Keyboard.
The Visitor provides the data, just as you provide data via the keyboard.
AnalogyVariable
********The Variable.
The guard writes the information down in a register (Variable) so it can be used later.
IntermediateConcatenation
x = input() (user types 10) + "10"?โ********"1010".
Since input returns a string "10", adding another string "10" performs concatenation, not math.
ArchitectSanitization
********Convert to expected type immediately.
Architects ensure data integrity by validating and converting raw input into its proper type (int, float) before using it.
Use CaseInteractive
input()?โ********Interactive Provisioning.
Scripts that require human decisions (e.g., "Which AWS Region?") are perfect for input().
Use CaseSafety
input() crucial for safety?โ********Confirmation steps.
Pausing to ask "Are you sure you want to delete this production bucket?" prevents catastrophic accidents.
AdvancedPrompt Message
input("...")?โ********It guides the user.
Without a prompt, the user sees a blinking cursor and doesn't know what data is expected.
ArchitectFlexibility
********Makes it dynamic.
Instead of hard-coding values like region="us-east-1", input allows one script to work for any region based on user choice.
Your Final Score:
0/20 Novice
Keep practicing to reach Architect level!
**# Linux/macOS
python3 -m venv my_devsecops_env
# Linux/macOS
source my_devsecops_env/bin/activate
# (You will see '(my_devsecops_env)' appear in your terminal prompt)
pip install requests
pip list # Only shows 'requests' and basic tools
deactivate
pip list # Shows your global system libraries (requests will be missing)
Objective: Learn to identify and fix common syntax and logic errors in Python scripts.
Scenario: A junior developer has written a script to track security vulnerabilities, but it is failing. You need to fix it.
The Broken Code:
1st_tool = "Bandit"
scanner-status = "Active"
total vulnerabilities = 5
print("Scanning with " + 1st_tool)
print("Vulnerabilities found: " + total vulnerabilities)
Task:
Fix the variable naming violations (Starting with number, hyphen, and spaces).
Fix the TypeError when printing the vulnerabilities (Type Casting).
Solution (The Architect Way):
tool_01 = "Bandit"
scanner_status = "Active"
total_vulnerabilities = 5
# Using f-string for clean output
print(f"Scanning with {tool_01}")
print(f"Vulnerabilities found: {total_vulnerabilities}")
Objective: Understand why venv is mandatory by intentionally breaking and then fixing a project environment.
Scenario: You have two DevSecOps scripts. Project A requires an old version of the requests library (2.10.0), but Project B requires the latest version.
Task:
Step 1: Create a directory named project_a and another named project_b.
Step 2: Inside project_a, create a venv, activate it, and run pip install requests==2.10.0.
Step 3: Inside project_b, create a separate venv, activate it, and run pip install requests==2.31.0.
Step 4: Run pip list in both to verify that Project A's version did not change when you installed Project B's version.
Verification:
python -c "import requests; print(requests.__version__)" in both environments. You should see different numbers!Objective: Learn to "Freeze" an environment so it can be recreated on any Linux server or GitHub Actions runner.
Scenario: You have finished developing a Python script for AWS IAM auditing. Now you need to give it to your DevOps team to run it in the pipeline.
Task:
Create a virtual environment and activate it.
Install the following DevSecOps libraries:
pip install boto3 (AWS SDK)
pip install bandit (Security Linter)
pip install safety (Dependency Checker)
The "Freeze" Step: Generate a requirements file:Bashpip freeze > requirements.txt
The "Recreation" Step: Deactivate the current venv, create a brand new one called prod_env, and install everything using only the file:Bashsource prod_env/bin/activate pip install -r requirements.txt
Architect Tip: Check the requirements.txt file. You will see not just the 3 libraries you installed, but also their "Sub-dependencies." This ensures 100% environment consistency.
Score: 0/20
20 Questions. Prove you can manage your dependencies like an Architect! Green = Correct, Red = Incorrect.
BeginnerAnalogy
********A Separate Kitchen.
Having a separate kitchen ensures that flavors (dependencies) from one dish (project) don't mix with and ruin another.
BeginnerProblem
********Version Conflicts.
It occurs when Project A needs requests==1.0 and Project B needs requests==2.0. You can't install both in the global Python.
ArchitectSystem Stability
********System Stability.
Linux tools like yum or dnf depend on specific versions of Python libraries. Messing with the global environment can crash your OS.
CoreMechanism
venv copy the entire Python installation?โ********No, it is lightweight.
venv creates a folder with a copy of the Python executable (or a link to it) and a separate site-packages folder, but shares the core files.
CommandCreation
python -m venv venv``**python create venv``**pip install venv``**make venv``**python -m venv venv.
You invoke the venv module using the -m flag. The second "venv" is just the name of the folder you want to create.
CommandLinux Activation
run venv``**source venv/bin/activate``**./venv/activate``**activate venv``**source venv/bin/activate.
You must "source" the script to modify your current shell's path variables.
CommandWindows Activation
source venv/bin/activate``**start venv``**.\venv\Scripts\Activate.ps1``**venv.exe``**.\venv\Scripts\Activate.ps1.
Windows stores scripts in a Scripts folder (not bin), and uses backslashes.
TroubleshootingCommon Error
********Forgot to activate.
If you don't activate, you are using the global Python, which doesn't have the libraries you installed inside the venv.
AdvancedLimitations
venv NOT install?โ********System-level libraries.
venv is for Python packages only. It cannot install OS dependencies like C headers or drivers; you need apt or Docker for that.
ArchitectCI/CD
venv important in CI/CD pipelines?โ********Security & Auditing.
A fresh venv ensures the build uses exactly what is in requirements.txt, reducing the attack surface and avoiding "pollution" from other builds.
ConceptDisposable
********Delete and recreate easily.
If an environment gets corrupted, you just delete the folder and run python -m venv venv again. It has no permanent effect on the OS.
ToolsVersions
********Pyenv.
venv creates isolated environments, but it relies on the installed Python. Pyenv installs different base Python versions.
CommandInstallation
python install all``**pip install -r requirements.txt``**venv update``**pip download requirements.txt``**pip install -r requirements.txt.
This is the standard command to read a list of packages and install them into the currently active environment.
BenefitConsistency
********Strict Versioning.
By isolating dependencies, you ensure everyone uses the exact same versions of libraries, preventing conflicts caused by global updates.
CommandExiting
deactivate``**exit``**quit``**stop venv``**deactivate.
This command reverts your shell's PATH variable back to the system default, effectively "turning off" the venv.
TroubleshootingMissing Command
python3 -m venv fails on Linux, what package is usually missing?โ********python3-venv.
On some Linux distros (like Ubuntu), the venv module is packaged separately to save space and must be installed via apt.
MechanismStorage
********Inside the 'venv' folder.
Specifically in venv/lib/pythonX.X/site-packages. This keeps them isolated from the rest of the system.
Best PracticeRequirements
********requirements.txt.
This is the Python standard convention for listing packages and their versions.
ConceptAttack Surface
********Only necessary packages.
By not including every global library, you reduce the risk of a vulnerability existing in unused code within your project environment.
ArchitectPortability
**pip freeze > requirements.txt``******pip freeze.
This command outputs the exact versions of all installed libraries, allowing you to replicate the environment precisely on another machine.
Your Final Score:
0/20 Novice
Keep practicing to reach Architect level!
**# Traditional way (Don't do this in Python)
a = 5
b = 10
temp = a
a = b
b = temp
print(a, b)
# Pythonic way (Do this!)
x = 50
y = 100
x, y = y, x
print(f"x is now {x}, y is now {y}")
server_config = ("192.168.1.1", 8080, "Production", "AWS", "Linux")
# Extract IP and Port, keep the rest as metadata
ip, port, *metadata = server_config
print(f"Connecting to {ip} on {port}")
print(f"Server Info: {metadata}")
Scenario: You want to initialize three different server lists for Development, QA, and Production. You decide to use "Chained Assignment" to save time.
a = b = [], you aren't creating three lists. You are creating one list with three tags. If you add a server to Dev, it magically appears in Prod too!print("--- The Trap ---")
# BAD PRACTICE for Mutable Objects
dev_servers = qa_servers = prod_servers = []
# We add a server ONLY to 'dev_servers'
dev_servers.append("dev-db-01")
print(f"Dev: {dev_servers}")
print(f"Prod: {prod_servers}")
# Output: Prod: ['dev-db-01']
# DISASTER! Production list got modified because they are the SAME object.
print("\n--- The Fix ---")
# CORRECT PRACTICE
# Create independent lists
dev_servers = []
qa_servers = []
prod_servers = []
dev_servers.append("dev-api-01")
print(f"Dev: {dev_servers}")
print(f"Prod: {prod_servers}")
# Output: Prod: [] (Clean and Safe)
x = y = []) for lists or dictionaries. Only use it for immutable things like numbers, booleans, or strings (x = y = 0).*)โScenario: You are parsing raw access logs from an Apache/Nginx server. The log format is [Timestamp, IP, Method, Path, ...UserAgent...].
Challenge: The User Agent string at the end might be split into many parts by spaces, or it might be short. You don't know the length.
Solution: Use the Star Operator to grab "everything else" into a list.
raw_log_line = ["2024-01-20", "192.168.1.5", "GET", "/login", "Mozilla/5.0", "(Windows", "NT", "10.0)"]
# We want specific fields for the first 4 items.
# We want to bundle the rest (User Agent) into one variable.
timestamp, client_ip, method, path, *user_agent_parts = raw_log_line
print(f"Alert: {client_ip} tried to access {path}")
# Reconstruct the User Agent string from the list
full_user_agent = " ".join(user_agent_parts)
print(f"User Agent: {full_user_agent}")
Output:
Alert: 192.168.1.5 tried to access /login
User Agent: Mozilla/5.0 (Windows NT 10.0)
_)โScenario: You are calling a function (like an AWS SDK method) that returns a tuple with 3 values: (Status, Message, RequestID).
Goal: You only care about the Status. You don't want to clutter your code with variables named msg or req_id that you never use.
Solution: Use the underscore _ as a "trash can" variable.
# Simulating a function that returns multiple values
def reboot_instance():
return ("SUCCESS", "Reboot initiated", "req-abc-123")
# Standard Unpacking:
# status, msg, req_id = reboot_instance() -> Wastes memory if we don't use msg/req_id
# Professional Unpacking:
# Use '_' for values you want to ignore.
status, _, _ = reboot_instance()
print(f"Operation Status: {status}")
Scenario: Let's prove that variables are just "Tags" and see exactly when Python decides to delete an object.
import sys
# 1. Create an object "CyberSecurity"
tag_1 = "CyberSecurity"
# 2. Check references
# Note: getrefcount returns a higher number because the function call itself creates a temporary reference.
print(f"Initial Refs: {sys.getrefcount(tag_1)}")
# 3. Add a second tag
tag_2 = tag_1
print(f"Refs after tag_2: {sys.getrefcount(tag_1)}") # Count increases
# 4. Remove tags
del tag_1
print("Deleted tag_1...")
# The object "CyberSecurity" is NOT deleted yet because tag_2 still holds it.
print(f"tag_2 still holds: {tag_2}")
# 5. Remove final tag
del tag_2
# Now the reference count hits 0. The Garbage Collector will eat the object immediatel
Output
Initial Refs: 4
Refs after tag_2: 5
Deleted tag_1...
tag_2 still holds: CyberSecurity
api_response = {"status": 200, "body": "OK"} # dict
server_list = ["10.0.0.1", "10.0.0.2"] # list
is_secure = True # bool
max_retries = 5 # int
latency = 0.45 # float
print(f"API is {type(api_response)}")
print(f"Latency is {type(latency)}")
port = 8080
msg = "Server running on port "
# print(msg + port) # CRASH: TypeError: can only concatenate str (not "int") to str
# Fix: Casting (converting)
print(msg + str(port)) # Works!
dirty_ips = ["192.168.1.1", "10.0.0.5", "192.168.1.1", "10.0.0.5"]
unique_ips = set(dirty_ips)
print(unique_ips)
# Output: {'10.0.0.5', '192.168.1.1'} (Duplicates gone instantly!)
Scenario: You are working with a JSON configuration file (represented as a Python Dictionary) for a Kubernetes Pod. You need to safely extract the "Image" name.
The Trap: Accessing a key that doesn't exist crashes the script with a KeyError.
The Fix: Use the .get() method.
# A typical nested dictionary (like a JSON file)
k8s_pod = {
"metadata": {
"name": "nginx-pod",
"namespace": "production"
},
"spec": {
"containers": [
{"name": "nginx", "image": "nginx:1.14.2"}
]
}
}
# 1. The Risky Way (Direct Access)
# If 'status' key is missing, this line crashes the script!
# print(k8s_pod["status"]["phase"]) # Uncommenting this causes KeyError
# 2. The Safe Way (Using .get)
# Returns 'None' or a default value instead of crashing
pod_phase = k8s_pod.get("status", "Unknown")
print(f"Pod Phase: {pod_phase}")
# 3. Accessing Nested Data
image_name = k8s_pod["spec"]["containers"][0]["image"]
print(f"Container Image: {image_name}")
.get() to prevent your entire pipeline from failing just because one optional field was missing.Scenario: You are reading Environment Variables to enable DEBUG mode.
The Problem: Environment variables are always Strings.
The Trap: bool("False") evaluates to True in Python! Why? Because any non-empty string is "Truthy".
# Simulation of reading an Env Variable
env_debug_value = "False" # This is what you get from os.environ
# BEGINNER MISTAKE:
is_debug_on = bool(env_debug_value)
print(f"Is Debug ON? {is_debug_on}")
# Output: True (Wait, what?? We set it to False!)
# ARCHITECT FIX:
# Compare the string value directly
real_debug_status = env_debug_value.lower() == "true"
print(f"Is Debug ON (Fixed)? {real_debug_status}")
# Output: False (Correct)
Scenario: You have a raw log line from a firewall. You need to extract the IP Address and the Error Code.
raw_log = "2024-01-20 10:00:01 | ERROR | 192.168.1.50 | Connection Refused"
# Split the string by the separator " | "
log_parts = raw_log.split(" | ")
print(f"Parsed Data: {log_parts}")
print(f"Type of data: {type(log_parts)}")
# Extract specific fields using List Indexing
timestamp = log_parts[0]
severity = log_parts[1]
ip_address = log_parts[2]
print(f"Alert! Malicious traffic from {ip_address} with severity {severity}")
Output:
Parsed Data: ['2024-01-20 10:00:01', 'ERROR', '192.168.1.50', 'Connection Refused']
Alert! Malicious traffic from 192.168.1.50 with severity ERROR
Scenario: You are storing database credentials in your script.
Goal: Ensure that no other part of the script can accidentally change the port number or password.
Solution: Use a Tuple.
# Tuple: (Host, Port, DB_Name)
db_config = ("db.prod.local", 5432, "users_db")
print(f"Connecting to {db_config[0]} on port {db_config[1]}...")
# Try to hack the port (Simulating a bug in code)
try:
db_config[1] = 8080 # Trying to change 5432 to 8080
except TypeError as e:
print(f"Security Blocked: {e}")
# Output: 'tuple' object does not support item assignment
Scenario: You are checking if a file is an image or a text file by looking at the header (magic bytes).
b"..." denotes a Byte Literal, distinct from a standard String.# A standard string
text_header = "PNG"
# A byte string (Machine readable data)
binary_header = b"PNG"
print(f"Type of text: {type(text_header)}") #
print(f"Type of binary: {type(binary_header)}") #
# They are NOT equal
print(f"Are they equal? {text_header == binary_header}") # False
Score: 0/20
20 Questions. Prove you know your Containers! Green = Correct, Red = Incorrect.
BeginnerAnalogy
********A Sealed Amazon Parcel.
Once packed (created), you cannot add, remove, or change items inside a tuple. It is Immutable.
BeginnerType ID
x = 5.0?โ********Float.
Python sees the decimal point and automatically assigns the type as float.
ArchitectBest Practice
type(x) == int``**isinstance(x, int)``**check_type(x)``**x.is_type(int)``**isinstance().
isinstance() supports inheritance (subclasses), whereas type() does not, making isinstance cleaner and safer.
IntermediateMutability
********List.
Lists are like backpacks; you can add, remove, or change the contents after creating them.
AdvancedDictionary Keys
********No.
Dictionary keys must be Immutable (Hashable). Since lists can change, they cannot be hashed and thus cannot be keys.
BeginnerStrong Typing
"5" + 5 in Python?โ********TypeError.
Python is Strongly Typed. It refuses to implicitly guess whether you want to do math or string concatenation. You must convert one type manually.
ArchitectDevSecOps
b"password" different from "password"?โ********One is Bytes, one is String.
Crucial for encryption and networking! Strings are text; Bytes are raw binary data. They are not interchangeable without encoding/decoding.
IntermediateUse Case
********Set.
Sets automatically remove duplicates. If you add the same IP twice, the set keeps only one.
IntermediateAnalogy
********A Phonebook.
You look up a "Key" (Name) to find the "Value" (Number).
ArchitectArchitecture
********Tuple.
Since tuples are immutable, they prevent accidental modification of critical configuration data during runtime.
BeginnerAnalogy
********A Solid Brick.
It is whole, unbreakable, and doesn't have parts (e.g., 5, 100).
BeginnerAnalogy
********A Necklace of Beads.
It is a sequence of individual characters strung together.
ArchitectLimitations
********Dynamic Typing Overhead.
Python has to check the type of every object at runtime before performing operations, adding overhead compared to statically typed languages.
AdvancedRisk
********Unintended side effects.
If a function modifies a list passed to it, the original list changes everywhere in your program.
IntermediateDynamic Typing
********Type is bound to the Object.
A variable is just a tag. You can move the tag from an Integer to a String without error.
ArchitectNetworking
********Bytes.
Network data is raw binary. You must decode it (bytes) into text (str) to read it.
BeginnerSyntax
[1, 2]``**(1, 2)``**{1, 2}``**<1, 2>``**Parentheses ().
Square brackets [] are for Lists, Curly braces {} are for Dicts/Sets.
BeginnerSyntax
("key", "value")``**["key", "value"]``**{"key": "value"}``**key = value``**Curly braces with colons {"k": "v"}.
This defines the Key-Value pair mapping.
IntermediateNull Value
None?โ********NoneType.
None is a special singleton object representing the absence of a value.
BeginnerAnalogy
********A Backpack.
You can put things in, take things out, and rearrange them (Mutable).
Your Final Score:
0/20 Novice
Keep practicing to reach Architect level!
**var = 100
print(f"Value: {var}, Type: {type(var)}, ID: {id(var)}")
var = "DevOps"
print(f"Value: {var}, Type: {type(var)}, ID: {id(var)}")
# Notice the ID is totally different. It's a new object.
def process_data(input_data):
if isinstance(input_data, list):
print(f"Processing list with {len(input_data)} items.")
elif isinstance(input_data, str):
print(f"Processing string: {input_data.upper()}")
else:
print("Error: Unsupported type!")
process_data(["Server1", "Server2"]) # Handles List
process_data("localhost") # Handles String
process_data(12345) # Handles Error safely
Scenario: You are writing a logging function for your cloud infrastructure. You want this function to write logs to any destinationโa physical file, a terminal, or a network streamโwithout changing the code.
.write() method?" If yes, it works.class FakeNetworkStream:
def write(self, message):
print(f"[Network Packet Sent]: {message}")
def secure_logger(output_device, message):
"""
I don't care what 'output_device' is.
I only care if I can .write() to it.
"""
output_device.write(f"LOG: {message}\n")
# 1. Use a Real File (Standard)
with open("system.log", "w") as f:
secure_logger(f, "System started.")
# 2. Use the Terminal (Standard Output)
import sys
secure_logger(sys.stdout, "System running...")
# 3. Use a Custom Class (Duck Typing)
network = FakeNetworkStream()
secure_logger(network, "System alert!")
Output:
system.log file is created.
Terminal shows: LOG: System running...
Terminal shows: [Network Packet Sent]: LOG: System alert!
Architect Insight: This makes Python incredibly flexible for testing. You can swap a real AWS S3 uploader with a "Fake" uploader class during unit tests easily.
Scenario: You scraped a website for prices, but the data is messy. Some are numbers (100), some are strings ("200"), and some are missing (None). You need to calculate the total cost.
The Trap: A simple loop will crash with a TypeError.
The Fix: Handle types dynamically inside the loop.
raw_prices = [100, "200", None, "50", 400, "Free"]
total_cost = 0
for item in raw_prices:
# Check the type before acting
if isinstance(item, int):
total_cost += item
elif isinstance(item, str):
# Try to convert string to int
if item.isdigit():
total_cost += int(item)
else:
print(f"Skipping text: '{item}'")
elif item is None:
print("Skipping missing data...")
print(f"Total Cost: ${total_cost}")
Output:
Skipping missing data...
Skipping text: 'Free'
Total Cost: $750
Scenario: You are querying a Cloud API.
If you search for one server, it returns a Dictionary.
If you search for all servers, it returns a List.
Challenge: Your script must handle both return types dynamically to avoid crashing.
def process_api_response(response):
# Dynamic Type Checking
if isinstance(response, dict):
# Handle Single Object
print(f"Processing Single Server: {response.get('id')}")
elif isinstance(response, list):
# Handle List of Objects
print(f"Processing Batch of {len(response)} Servers:")
for server in response:
print(f" - {server.get('id')}")
else:
print("Error: Unknown API format.")
# Simulating API Calls
api_single = {"id": "i-12345", "state": "running"}
api_batch = [{"id": "i-67890"}, {"id": "i-11223"}]
process_api_response(api_single) # Works
process_api_response(api_batch) # Works too!
isinstance() before iterating!Scenario: You are working on a large team. You write a function to calculate server uptime. You want to tell your teammates explicitly that start_time must be an integer (timestamp), not a string.
# The syntax: variable: type
# The arrow -> type: indicates return type
def calculate_uptime(start_time: int, current_time: int) -> int:
return current_time - start_time
# Correct Usage
uptime = calculate_uptime(1600000000, 1600003600)
print(f"Uptime: {uptime} seconds")
# Incorrect Usage (Python runs it, but IDEs like VS Code will underline it in RED)
# This helps catch bugs before you even run the code!
# crash = calculate_uptime("yesterday", "today")
id() Reassignment ProofโScenario: Visually proving that "Changing a variable" is actually "Moving a tag to a new box."
# Tag 'x' is on Box 50
x = 50
addr1 = id(x)
print(f"x is {x} at address {addr1}")
# Move Tag 'x' to Box 60
x = 60
addr2 = id(x)
print(f"x is {x} at address {addr2}")
# Check if they are the same spot in memory
if addr1 != addr2:
print("Proof: The variable moved to a completely new memory location!")
Score: 0/20
20 Questions. Sticker vs. Box. Strong vs. Weak. Green = Correct, Red = Incorrect.
BeginnerAnalogy
********The Engraved Box.
In Static typing, the container (variable) enforces the type. If the box says "Shoes Only", you cannot put a Pizza in it.
BeginnerAnalogy
********The Sticker Gun.
You create a label (variable) and can stick it on anything (Integer, String, etc.). The sticker doesn't care what it's attached to.
CoreType Binding
********The Object in Memory.
The variable is just a name tag. The actual object (e.g., the number 5) holds the type information.
IntermediateReassignment
x = 5 then x = "Guru"?โ********Allowed.
You are simply peeling the sticker off the Integer 5 and sticking it onto the String "Guru".
IntermediateType Checking
********Runtime.
Python checks the type only when the code actually runs. This is why some bugs can hide until that specific line is executed.
BeginnerComparison
********Compile Time.
The compiler screams at you before you can even run the program if you violate type rules.
AdvancedClassification
********Strongly Typed.
Do not confuse Dynamic with Weak. Python is Strong because it forbids implicit weird conversions like 1 + "1".
AdvancedStrong vs Weak
1 + "1" in Python?โ********TypeError.
JavaScript (Weak) would give "11". Python (Strong) refuses to mix types implicitly.
ArchitectRisk
********Runtime Errors.
If a variable unexpectedly holds None instead of a User object, the script crashes only when that line is hit in production.
ArchitectModern Python
********Type Hints.
Example: age: int = 25. This helps IDEs and linters catch errors before you run the code.
AdvancedType Hints
********No.
Type hints are for developers and tools (like MyPy). The Python interpreter completely ignores them at runtime.
ConceptDuck Typing
********If it walks/quacks like a duck...
Python doesn't care about the official class type. It only cares if the object has the methods/behaviors you are trying to use.
IntermediateDuck Typing Example
**.read() method******No.
If you create a custom class that has a .read() method, Python will happily treat it like a file.
AdvancedPerformance
********Runtime Type Checking overhead.
Python has to ask "What type is this?" every single time you touch a variable, whereas C++ knows the type in advance.
BenefitUse Case
********Less Boilerplate.
You don't need to write int, float, string everywhere. You just write logic, making it faster to write.
IntermediateGeneric Functions
********Natural support.
Since Python doesn't enforce types on arguments, a single function process(data) can handle Lists, Tuples, or JSON without extra code.
SyntaxType Hinting
age: int = 25``**int age = 25``**var age = 25``**age = (int) 25``**age: int = 25
This syntax (introduced in PEP 484) allows you to annotate the expected type.
ArchitectMemory
x = 5 is reassigned to x = "Guru", what happens to the 5?โ********It is Garbage Collected.
Since the label x no longer points to 5, the reference count for 5 drops to zero, and the Cleaning Crew deletes it.
IntermediateComparison
********No.
In Static typing, the type is tied to the variable (The Box). You cannot put a String into a variable declared as an Integer.
ArchitectCode Readability
********Not knowing a variable's type.
In large scripts, seeing a variable named data is confusing. Is it a list? A dict? A string? Static typing avoids this ambiguity.
Your Final Score:
0/20 Novice
Keep practicing to reach Architect level!
**x = 100
y = 100
print(f"Address of x: {id(x)}")
print(f"Address of y: {id(y)}")
print(f"Are they the same object? {x is y}")
# Output: True (Because 100 is small and cached)
a = 9999
b = 9999
print(f"Are big numbers same? {a is b}")
# Output: False (Usually, unless your editor optimizes it!)
import sys
message = "DevSecOps"
# The count is 2 (one for variable 'message', one for the argument passed to getrefcount)
print(f"References: {sys.getrefcount(message)}")
copy_msg = message
print(f"References after copy: {sys.getrefcount(message)}")
# Output: Increases by 1
Scenario: You are writing a script that updates a server configuration. You need to know: if I update a variable, does it change the memory address?
Immutable (Integers, Strings, Tuples): Changing the value forces Python to create a new object.
Mutable (Lists, Dictionaries): Changing the content keeps the same object (same address).
print("--- Immutable Test (Integer) ---")
x = 100
print(f"Original x: {x}, Address: {id(x)}")
x = x + 1 # We modify x
print(f"New x: {x}, Address: {id(x)}")
# Result: The Address CHANGES! The old '100' is abandoned.
print("\n--- Mutable Test (List) ---")
servers = ["Web-01", "Web-02"]
print(f"Original List: {servers}, Address: {id(servers)}")
servers.append("Web-03") # We modify the list in-place
print(f"New List: {servers}, Address: {id(servers)}")
# Result: The Address STAYS THE SAME! Efficient memory usage.
s = s + "new") is slow (expensive), because string concatenation constantly creates new objects in memory.Scenario: You want to copy a list of firewall rules to a "Backup" variable before applying changes. You use the standard slicing method [:]. The Trap: This creates a Shallow Copy. The outer list is new, but the items inside still point to the same memory addresses as the original!
import copy
# A list containing a sub-list (Nested Data)
# Think of this as [Rule-Group-ID, [Port-List]]
firewall_rules = [101, [80, 443]]
# 1. Standard Assignment (Reference only - Danger!)
alias = firewall_rules
# 2. Shallow Copy (Slicing - Safe for top level, Unsafe for nested)
backup_shallow = firewall_rules[:]
# 3. Deep Copy (The Real Clone - Totally Safe)
backup_deep = copy.deepcopy(firewall_rules)
print(f"Original: {firewall_rules}")
# Let's Modify the Inner List (The Port List)
print("\n...Hacking the original list...")
firewall_rules[1].append(22) # Adding SSH port 22
print(f"Original: {firewall_rules}")
print(f"Alias: {alias}") # Changed (Expected)
print(f"Shallow Backup: {backup_shallow}") # CHANGED! (Trap Triggered!)
print(f"Deep Backup: {backup_deep}") # Unchanged (Safe)
copy.deepcopy() to avoid accidental data corruption.Scenario: Your script processes massive log files (GBs of size). You delete the variable log_data to free space, but your OS shows RAM is still full. Why? Concept: Sometimes Python is "lazy" about returning memory. You can force it.
import gc
import sys
# Create a massive list (consumes RAM)
# 10^6 integers
big_data = [i for i in range(1000000)]
print(f"References to big_data: {sys.getrefcount(big_data)}")
# Delete the variable tag
del big_data
# At this point, the list is 'unreachable', but Python might not have cleaned it yet.
# Let's force the cleaning crew to run NOW.
collected = gc.collect()
print(f"Garbage Collector: Cleaned up {collected} objects.")
print("Memory should be freed now.")
gc.collect() after a heavy processing job can prevent your server from running out of RAM (OOM Kill).sys.getsizeof() Reality CheckโScenario: You are optimizing a script. You want to know which data structure uses less RAM: a List or a Tuple?
import sys
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
print(f"Size of List: {sys.getsizeof(my_list)} bytes")
print(f"Size of Tuple: {sys.getsizeof(my_tuple)} bytes")
Output (Typical):
List: ~104 bytes
Tuple: ~80 bytes
Why? Lists are mutable, so Python allocates extra "buffer" memory to them so you can append items later without re-allocating everything immediately. Tuples are fixed, so they are perfectly sized.
Takeaway: For static configuration data that never changes, always use Tuples. It saves RAM.
Score: 0/20
20 Questions based on the "Warehousing & Cleaning Crew" analogy. Green = Correct, Red = Incorrect.
BeginnerAnalogy
********The Shelves (Data storage).
The Heap is the physical area where objects (products) are stored. The Stack is just the catalog of references (labels).
BeginnerVariable Creation
x = 10?โ********Two-step process: Heap object, Stack reference.
Python creates the object 10 first (if not cached) in the Heap, then creates the label x in the Stack pointing to it.
IntermediateReferences
x = y?โ********It copies the pointer.
Both variables end up pointing to the exact same object in the Heap. No new object is created.
ArchitectGarbage Collection
********Reference Counting.
This is real-time. As soon as the count hits zero (no labels left), the object is destroyed immediately.
AdvancedCyclic References
********To handle Cyclic References.
If Object A points to B, and B points to A, their ref count never hits zero. The Generational GC scans for these isolated loops.
AdvancedGenerations
********3 Generations (0, 1, 2).
New objects start in Gen 0. If they survive a cleanup, they are promoted to Gen 1, and eventually Gen 2.
ArchitectInterning
********-5 to 256.
These integers are pre-allocated singletons. Every time you use them, you reference the existing object rather than creating a new one.
AdvancedTools
sys.getrefcount(obj)``**gc.count(obj)``**inspect.refs(obj)``**id(obj)``**sys.getrefcount(obj).
This debugging tool shows how many variables are currently pointing to a specific object.
IntermediateMemory Address
id(obj) function return?โ********The unique memory address.
It's like the physical shelf number in the warehouse. You use it to check if two variables point to the exact same location.
ArchitectLimitations
********A micro-pause.
When the GC runs on Generation 2 (old objects), it may briefly pause the program. This is critical to know for high-frequency trading apps.
IntermediateComparison
== and is?โ== checks values, is checks memory IDs**== checks memory IDs, is checks values****is is for math only**is checks memory IDs.
a is b returns True only if they point to the same object. a == b checks if the data inside is equivalent.
AdvancedManual Control
sys.clean()``**delete all``**gc.collect()``**memory.free()``**gc.collect().
While rarely needed, you can use this in heavy scripts to force the "Cleaning Crew" to run immediately.
BeginnerDeletion
del x do?โ********Removes the name and decrements count.
You never delete objects manually. You just remove the label. If the count hits zero, the GC handles the deletion.
ArchitectOverhead
********The Object Header.
Every Python object carries metadata (type, reference count) which adds significant overhead compared to raw C data types.
BeginnerSafety
********Segmentation Faults.
Because you don't manually manage memory (malloc/free), you avoid accessing invalid memory addresses, making Python safer.
AdvancedData Location
********On the private Heap.
All actual data objects live in the Heap. The Stack only contains the references (names) pointing to them.
ArchitectMemory Leaks
********A Reference Cycle.
Complex structures referring to each other can fool the reference counter. If the Generational GC doesn't run or clean them, RAM usage grows.
AdvancedStack Allocation
********References (Variable Names).
The Stack is fast and structured, used for managing function calls and variable names (pointers), while the heavy data sits in the Heap.
BeginnerManagement
malloc or free?โ********No, it is Automatic.
The CPython Memory Manager handles all allocation and deallocation behind the scenes.
ArchitectOptimization
id() important for optimization?โ********To check for needless copying.
If two variables have different IDs when they should be sharing data, you might be wasting RAM by duplicating objects.
Your Final Score:
0/20 Novice
Keep practicing to reach Architect level!
**text = "DevOps"
print(f"Original ID: {id(text)}")
text = text + " Guru"
print(f"New ID: {id(text)}")
# Result: IDs are different. Python created a new string object.
# A Tuple containing a List
secure_config = ("127.0.0.1", [80, 443])
# secure_config[0] = "10.0.0.1" # Error: Tuple allows no change.
# BUT, we can change the list inside!
secure_config[1].append(8080)
print(secure_config)
# Output: ('127.0.0.1', [80, 443, 8080]) -> Modified!
user_input = " 500 " # Note the spaces
try:
# 1. Strip spaces, 2. Convert
value = int(user_input.strip())
print(f"Processing amount: {value}")
except ValueError:
print("Error: Please enter a valid number.")
Scenario: You are writing a script to generate a massive report string from thousands of log lines.
The "Bad" Way: Using += on a string. Since strings are Immutable, Python has to destroy and recreate the entire string variable for every single line. This kills the CPU.
The "Architect" Way: Use a List (Mutable) to collect parts, then join them once.
import time
# Simulation: 100,000 log lines
log_lines = ["Error: Connection timeout" for _ in range(100000)]
# --- METHOD 1: The Slow Way (Immutable Concatenation) ---
start_time = time.time()
report = ""
for line in log_lines:
report += line + "\n" # DANGER: Creates a NEW object 100,000 times!
print(f"Bad Method took: {time.time() - start_time:.4f} seconds")
# --- METHOD 2: The Fast Way (Mutable List Buffer) ---
start_time = time.time()
buffer_list = []
for line in log_lines:
buffer_list.append(line) # Fast! Modifies list in-place.
final_report = "\n".join(buffer_list) # Creates string ONCE at the end.
print(f"Architect Method took: {time.time() - start_time:.4f} seconds")
Expected Output: You will see the "Architect Method" is significantly faster (often 100x faster for large datasets).
Scenario: You want to create a dictionary that maps a specific set of Open Ports (e.g., [80, 443]) to a Security Group Name.
The Rule: Dictionary keys must be Immutable (Hashable).
The Error: Using a List as a key triggers a TypeError.
# Goal: Map a list of ports to a Profile Name
# key: [80, 443] -> value: "Web-Server-Profile"
try:
# ATTEMPT 1: Using a List (Mutable) as a Key
port_list = [80, 443]
security_map = {
port_list: "Web-Server-Profile"
}
except TypeError as e:
print(f"CRASH: {e}")
# Output: unhashable type: 'list'
# ATTEMPT 2: The Fix - Cast to Tuple (Immutable)
port_tuple = tuple([80, 443]) # Explicit Casting
security_map = {
port_tuple: "Web-Server-Profile"
}
print(f"Success! Profile mapped: {security_map[port_tuple]}")
tuple or frozenset first.Scenario: You are reading data from a chaotic CSV file where numbers are written as strings like " 500ms " or "1,000". If you cast directly, it crashes.
raw_data = [" 500 ", "1,000", "N/A", "200"]
cleaned_values = []
for entry in raw_data:
try:
# Step 1: Clean the string (Remove spaces, remove commas)
clean_str = entry.strip().replace(",", "")
# Step 2: Explicit Cast to Integer
val = int(clean_str)
cleaned_values.append(val)
except ValueError:
# Handle cases like "N/A" gracefully
print(f"Skipping invalid data: '{entry}'")
print(f"Cleaned Data: {cleaned_values}")
# Output: [500, 1000, 200]
int()) is strict. It does not guess. You must "sanitize" the string (remove commas, spaces) before asking Python to convert it.Scenario: You defined an "Immutable" configuration tuple to protect your server list. But a hacker (or a buggy function) modified the data anyway.
# A tuple representing (Datacenter_Name, [Server_List])
dc_config = ("US-East-1", ["Server A", "Server B"])
print(f"Original Config: {dc_config}")
# 1. Try to change the Datacenter Name (Immutable String)
try:
dc_config[0] = "US-West-2"
except TypeError:
print("Blocked: Cannot change Datacenter Name.")
# 2. Try to add a server to the list (Mutable List inside Tuple)
dc_config[1].append("Malicious-Server-X")
print(f"Hacked Config: {dc_config}")
# Output: The list inside is now modified!
("US-East-1", ("Server A", "Server B")).Scenario: A deployment script reads ENABLE_DELETION = "False" from a text file. The script accidentally deletes the database because it thought "False" was True.
config_value = "False"
# BAD PRACTICE (Implicit Casting)
# Any non-empty string is evaluated as True in a boolean context
if config_value:
print("DANGER: Deletion Enabled! (The string is not empty)")
# ALSO BAD (Explicit Casting)
# bool("False") is True because the string has characters in it
if bool(config_value):
print("DANGER: bool('False') is actually True!")
# CORRECT PRACTICE (Comparison)
if config_value.lower() == "true":
print("Deletion Enabled.")
else:
print("SAFE: Deletion Disabled.")
Score: 0/20
20 Questions. Understanding the "Certificate vs Google Doc" analogy. Green = Correct, Red = Incorrect.
BeginnerAnalogy
********A Printed Certificate.
If you want to change a string, you can't edit it. You must print a brand new one (create a new object).
IntermediateMemory ID
x = 10 (ID: 1001), what happens to the ID after x = x + 1?โ********ID changes.
Integers are immutable. Adding 1 creates a totally new object in memory, and x is moved to point to it.
IntermediateMemory ID
lst = [1, 2] (ID: 5001), what happens to the ID after lst.append(3)?โ********ID stays 5001.
Lists are mutable (Google Docs). You are updating the existing object in place without creating a new one.
BeginnerClassification
********Tuple.
Lists, Sets, and Dictionaries are all Mutable. Tuples, Strings, and Numbers are Immutable.
ArchitectDict Keys
********Lists are Mutable (Unhashable).
If the key changes content, its "Hash" changes, and Python would lose track of the value. Keys must be Immutable.
ArchitectThread Safety
********Immutable types.
Since they cannot be modified, multiple threads can read them simultaneously without needing locks.
IntermediateType Casting
int(3.99)?โ********3 (Data Loss via Truncation).
Casting a float to an int in Python always cuts off the decimal part; it does not round.
IntermediateLogic Error
bool("False")?โ********True.
Any non-empty string is "Truthier" in Python. Only an empty string "" evaluates to False.
AdvancedFrozen Set
********frozenset().
Normal sets are mutable and unhashable. A frozenset is immutable and can be used as a key.
IntermediateImplicit Bool
********[] (Empty List).
Empty collections (lists, tuples, dicts) and 0 are False. Non-empty collections and non-zero numbers are True.
ArchitectPythonic Style
if my_list:``**if len(my_list) > 0:``**if my_list != []:``**if my_list is not None:``**if my_list:
This leverages Implicit Boolean Conversion. If the list has items, it is True. If empty, it is False.
AdvancedPerformance
s += " word" bad inside a massive loop?โ********It creates a new object every iteration.
Since strings are immutable, Python has to create a new, larger string in memory for every single addition, killing performance.
ArchitectOptimization
****''.join(list)``****Collect in a list, then join.
Appends to a list are cheap (O(1)). Joining them at the end happens in one go.
AdvancedThe Loophole
t = (1, [a]))โ********Yes (The Tuple Loophole).
The tuple protects the reference to the list, but it does not protect the contents of the list itself.
BeginnerReassignment
s.append("new")``**s = s + "new")**s.update("new")``****Reassignment (Rebinding).
You aren't changing the old object; you are creating a new one and moving the variable tag to point to it.
IntermediateUse Case
********Data buffers and dynamic logs.
When you need to frequently add, remove, or change items efficiently, use a Mutable type.
IntermediateUse Case
********Ensuring data integrity.
If you have data that should not change (like server coordinates), use a Tuple to prevent accidental modification.
BeginnerCasting
tuple([1, 2]) return?โ[1, 2]``**(1, 2)``**{1, 2}``**1, 2 (String)**(1, 2).
It converts the mutable list into an immutable tuple.
ArchitectDynamic Typing
********A variable is just a label.
x can point to an Integer now, and later be reassigned to point to a String. The type belongs to the object, not the name.
IntermediateSet
set Mutable or Immutable?โ********Mutable.
You can add and remove items from a standard set ({1, 2}). That is why you cannot use a set as a dictionary key (unless it's a frozenset).
Your Final Score:
0/20 Novice
Keep practicing to reach Architect level!
**Open VS Code.
Install the "Pylint" extension.
Write this code: MyVariable = 10
Hover over the variable. You will see a warning: "Variable name "MyVariable" doesn't conform to snake_case naming style."
Lab 2: Refactoring Practice converting these names:
employeeID -> employee_id
calculate_Salary -> calculate_salary
API_URL (Keep as is! It's a constant)
server = "Prod-DB-01"
ip = "192.168.1.50"
# Method 1: Comma (Lazy but works)
print("Server:", server, "has IP:", ip)
# Method 2: Concatenation (Harder)
print("Server: " + server + " has IP: " + ip)
# Method 3: f-string (The Pro Way - Use this!)
print(f"Server: {server} has IP: {ip}")
cost = 49.9999
print(f"Server Cost: ${cost:.2f}")
# Output: Server Cost: $50.00 (Rounded automatically!)
sep)โScenario: You are building a script that asks the user to choose an environment (Dev, QA, Prod). You want to print a clean menu without writing print() five times.
Concept: The sep (separator) parameter.
print("--- AWS Environment Selector ---")
# Instead of 4 separate print statements, use one with 'sep' set to a new line (\n)
print("1. Development", "2. QA Testing", "3. Pre-Production", "4. Production", sep="\n")
print("--------------------------------")
#output
--- AWS Environment Selector ---
1. Development
2. QA Testing
3. Pre-Production
4. Production
--------------------------------
Scenario: You scraped a list of servers and their status. You need to print them in a neat table where columns align perfectly, even if the server names have different lengths.
Concept: F-string Padding/Alignment.
< : Align Left
> : Align Right
^ : Align Center
20: Reserve 20 spaces for this text.
# Variables with different lengths
s1_name, s1_status, s1_cpu = "web-server-01", "Running", 15
s2_name, s2_status, s2_cpu = "db-backup-primary", "Stopped", 0
s3_name, s3_status, s3_cpu = "api-gateway", "High-Load", 92
# The Header
print(f"{'SERVER NAME':<20} | {'STATUS':^12} | {'CPU %':>6}")
print("-" * 45) # Prints a divider line easily
# The Rows (Notice the padding numbers match the header)
print(f"{s1_name:<20} | {s1_status:^12} | {s1_cpu:>6}%")
print(f"{s2_name:<20} | {s2_status:^12} | {s2_cpu:>6}%")
print(f"{s3_name:<20} | {s3_status:^12} | {s3_cpu:>6}%")
#Output
SERVER NAME | STATUS | CPU %
---------------------------------------------
web-server-01 | Running | 15%
db-backup-primary | Stopped | 0%
api-gateway | High-Load | 92%
Why this matters: When you want a report, readability is everything. This logic is used in almost every CLI tool (like kubectl get pods).
Scenario: Your script is failing. You need to quickly check the value of a variable, but you are tired of typing print("x =", x).
Concept: The = specifier inside f-strings. It prints the expression and the value together.
api_key = "Ax78-9900-Z"
timeout = 400
# The Old/Slow Way
print("api_key =", api_key)
# The Pro Way (Self-documenting expression)
print(f"{api_key=}")
print(f"{timeout=}")
# You can even do math inside it!
a = 10
b = 5
print(f"{a + b = }")
#Output
api_key = Ax78-9900-Z
api_key='Ax78-9900-Z'
timeout=400
a + b = 15
Scenario: You are working on Windows but your server is Linux. Windows uses backslash \ and Linux uses forward slash /. Hardcoding paths causes errors.
Concept: While os.path is the official way, print helps us visualize paths safely using "Raw Strings" (r"").
folder = "var"
subfolder = "log"
filename = "syslog.txt"
# Normal strings interpret '\' as an escape character (like \n for newline)
# So specific Windows paths fail.
# Using Raw String (r) treats backslashes as text, not commands.
windows_path = r"C:\Users\Admin\Documents"
# Building a path dynamically
print(f"Linux Path: /{folder}/{subfolder}/{filename}")
print(f"Windows Path: {windows_path}")
#Output
Linux Path: /var/log/syslog.txt
Windows Path: C:\Users\Admin\Documents
Score: 0/20
20 Questions. Prove your mastery of Python's printing mechanics. Green = Correct, Red = Incorrect.
BeginnerAnalogy
print()?โ********The Camera & Projector.
Calculations happen in the dark (memory). print() beams the result onto the screen so you can see it.
BeginnerBasic Output
print() send data by default?โ********Standard Output (stdout).
By default, it prints to your terminal or console.
BeginnerComma vs Plus
,) method?โ********It handles all data types automatically.
Unlike +, the comma method works with numbers, lists, and objects without needing str() conversion, and adds a space automatically.
IntermediateErrors
print("Age: " + 25)?โ********CRASH! TypeError.
The + operator requires both sides to be strings. You cannot add a string to an integer without converting it first.
Advancedf-strings
print(f"Value: [x]")``**print(f"Value: {x}")``**print("Value: {x}".f)``**print(format"Value: {x}")``**print(f"Value: {x}")
You put an f before the quotes and wrap variables in curly braces {}.
IntermediateSeparators
sep parameter?โ" "``**""``**","``**"\n"``**A single space.
When you use commas (print(a, b)), Python inserts a space between items by default.
IntermediateEnd Parameter
end parameter?โ****\n)**\t)**Newline (\n).
This is why every print() call usually starts on a new line unless you change end="".
ArchitectUse Case
print("...", sep="")``**print("...", end="")``**print("..." + "\r")``**sys.stdout.flush() only**Use end="".
Setting end="" prevents Python from jumping to the next line, allowing subsequent prints to appear on the same row.
ArchitectLogging
sys.stdout``**sys.stderr``**sys.stdin``****sys.stderr.
Tools like Splunk or Datadog categorize logs based on the stream. Errors should always go to stderr so they are flagged correctly.
AdvancedPerformance
********Writing to screen is slow.
Compared to CPU calculations (nanoseconds), sending data to the terminal (milliseconds) is extremely slow. Too many prints will slow down high-performance scripts.
IntermediateObject Printing
__str__ method?โ********It prints a memory address.
You'll see something like <__main__.MyObject object at 0x7f...> unless you define a __str__ or __repr__ method.
IntermediateOld School
+ (Concatenation) for printing?โ********TypeError if types don't match.
It's strict. You must manually convert every non-string to a string using str(), which is verbose and error-prone.
AdvancedVariadic
print() is "Variadic"?โ********Accepts unlimited arguments.
You can pass as many items as you want: print(a, b, c, d, e...).
BeginnerFormat Output
print("A", "B", sep="-")?โ********A-B.
The sep parameter replaces the default space with the dash -.
AdvancedStandard
********Python 3.6.
They are the modern industry standard for string formatting.
IntermediateString Conversion
print() automatically convert numbers to strings?โ********Yes, always.
Unlike concatenation (+), the print() function calls str() internally on every argument passed to it.
ArchitectLegacy
****%``****The Modulo % (C-style).
Example: print("Age %d" % 10). This is valid but discouraged in modern Python code.
IntermediateFixing Errors
print("ID: " + 101) without changing the logic?โprint("ID: " + int(101))``**print("ID: " + str(101))``**print("ID: " * 101)``**print("ID: ", 101)``**str(101)
If you must use concatenation (plus), you must explicitly convert the number to a string first.
ArchitectFormatting Chaos
********f-strings.
Instead of "User " + name + " ID " + str(id), you write f"User {name} ID {id}". It's cleaner and readable.
IntermediateFormat Method
.format() vs f-strings?โ********It is slightly verbose.
"Value: {}".format(x) separates the logic (variables) from the string, whereas f-strings keep them together for better readability.
Your Final Score:
0/20 Novice
Keep practicing to reach Architect level!
**raw_time = "200ms"
# Step 1: Clean the data (Remove 'ms')
clean_time_str = raw_time.replace("ms", "")
# Step 2: Cast to Integer
time_int = int(clean_time_str)
# Step 3: Logic
if time_int > 100:
print("Alert: Latency is high!")
pi = 3.14159
gravity = 9.8
# Implicit (No data loss)
combined = pi + gravity
print(f"Implicit Sum: {combined}") # 12.94159
# Explicit (Data loss)
truncated_pi = int(pi)
print(f"Integer Pi: {truncated_pi}") # 3 (Decimal lost)
Scenario: You are configuring a firewall script. The allowed IP addresses are passed as a single Environment Variable string (e.g., "10.0.0.1,10.0.0.2").
The Trap: If you use list(), it splits the string into individual characters!
The Fix: You must use the .split() string method to create a list of items.
import os
# Simulating an Environment Variable
# format: "IP1,IP2,IP3"
env_allowed_ips = "192.168.1.10,192.168.1.20,10.5.5.1"
# --- WRONG WAY (Casting) ---
# This breaks the string into characters: ['1', '9', '2', ...]
wrong_list = list(env_allowed_ips)
print(f"Wrong List size: {len(wrong_list)}") # Output: 34 (Huge list of chars!)
# --- CORRECT WAY (Splitting) ---
# This splits the string at every comma
correct_list = env_allowed_ips.split(",")
print(f"Correct List: {correct_list}")
# Output: ['192.168.1.10', '192.168.1.20', '10.5.5.1']
# Architect Bonus: Clean up spaces just in case "IP, IP" was used
cleaned_list = [ip.strip() for ip in correct_list]
list() constructor is for iterables (things you can loop over). .split() is for separators. Don't confuse them!Scenario: You are consuming an old legacy API that returns everything as strings, even numbers and booleans. You need to sanitize this data before storing it in your modern database.
# The messy data from the old API
legacy_payload = {
"server_id": "9901",
"is_active": "true", # Lowercase string
"cpu_load": "45.5",
"tags": "web,prod,aws"
}
# The Sanitizer Logic
cleaned_data = {
# 1. Cast String to Integer
"id": int(legacy_payload["server_id"]),
# 2. Compare String to Boolean (Safest way)
"active": legacy_payload["is_active"].lower() == "true",
# 3. Cast String to Float
"load": float(legacy_payload["cpu_load"]),
# 4. Split String to List
"tags": legacy_payload["tags"].split(",")
}
print("Sanitized Data Schema:")
print(cleaned_data)
# Output: {'id': 9901, 'active': True, 'load': 45.5, 'tags': ['web', 'prod', 'aws']}
Scenario: You are generating a SHA-256 checksum for a file to verify its integrity.
The Challenge: Hashing libraries return bytes (binary data like b'\xea\x98...'). You cannot print this effectively or save it to a text report.
The Fix: You must convert (decode) the bytes into a Hexadecimal String.
import hashlib
data = "MySecurePassword123"
# Step 1: Encode String to Bytes (Computers need bytes for math)
data_bytes = data.encode("utf-8")
# Step 2: Generate Hash (Returns binary object)
hash_object = hashlib.sha256(data_bytes)
binary_hash = hash_object.digest()
print(f"Raw Binary: {binary_hash}")
# Output: b'...' (Unreadable garbage characters)
# Step 3: Convert to Hex String (The "DevOps" way)
# .hexdigest() handles the casting from bytes to hex string automatically
readable_hash = hash_object.hexdigest()
print(f"Readable Hash: {readable_hash}")
# Output: 9f86d081884c7d659... (Standard readable hash)
utf-8) and Bytes (b''). Remember: str.encode() $\rightarrow$ Bytes, bytes.decode() $\rightarrow$ String.Scenario: You are building a utility library for your team. You want a function to_int that never crashes your script, even if the input is garbage.
def safe_int_cast(value, default=0):
"""
Tries to convert value to int.
If it fails (None, text, etc.), returns the default value.
"""
try:
# Handle cases where input is purely None
if value is None:
return default
# Try to cast
return int(float(value)) # Using float first handles "5.5" string cases
except (ValueError, TypeError):
print(f"Warning: Could not cast '{value}'. Using default.")
return default
# Test Cases
print(safe_int_cast("100")) # 100
print(safe_int_cast("50.99")) # 50 (Truncated)
print(safe_int_cast("NotNumber")) # 0 (Default, warning printed)
print(safe_int_cast(None)) # 0 (Default)
Scenario: You are setting file permissions (chmod). Linux permissions like 0777 are Octal numbers, not Decimals.
The Trap: int("0777") converts it to Decimal 777. This is wrong for os.chmod!
The Fix: Tell int() the base.
permission_str = "0755"
# WRONG: Default is base 10
wrong_perm = int(permission_str)
print(f"Base 10 Value: {wrong_perm}") # 755 (Decimal)
# CORRECT: Base 8 (Octal)
# This is what Linux expects for permissions
correct_perm = int(permission_str, 8)
print(f"Base 8 Value: {correct_perm}") # 493 (Decimal equivalent of 0o755)
# Proof using Python's oct() display
print(f"Octal Display: {oct(correct_perm)}") # 0o755
Score: 0/20
20 Questions. Prove you know the difference between implicit and explicit! Green = Correct, Red = Incorrect.
BeginnerDefinition
********Changing one data type into another.
Type Casting is the process of converting a variable from one type (like a String) to another (like an Integer).
BeginnerAnalogy
********The Physical Adapter.
Explicit conversion is manual. Just like you must buy and plug in an adapter to fit a US socket, you must use functions like int() to force the change.
IntermediateImplicit
10 + 2.5 in Python?โ********12.5 (Float).
This is Implicit Conversion. Python automatically promotes the Integer to a Float to prevent data loss.
BeginnerSyntax
"500" to a number?โint("500")``**num("500")``**str("500")``**change("500")``**int("500").
int() is the constructor function used to manually convert a compatible string into an integer.
ArchitectAPI Reality
********Data arrives as Strings.
Even if a value is a number (like port 8080), APIs usually send it as a string "8080". You must cast it to use it in logic.
AdvancedData Loss
int(9.9)?โ********9 (Truncates).
Converting a float to an int results in Truncation. The decimal part is removed permanently, not rounded.
TrapFloat String
int("10.5")?โ********ValueError (Crash).
Python cannot directly convert a string with a decimal point into an integer. You must use float() first, or it will crash.
SolutionFixing Errors
"10.5" to the integer 10?โint("10.5")``**int(float("10.5"))``**round("10.5")``**str(10.5)``**int(float("10.5"))
First convert the string to a float: float("10.5") -> 10.5. Then convert that float to an int: int(10.5) -> 10.
TrapBoolean Trap
bool("False")?โ********True.
Any non-empty string is evaluated as True in Python. This is the #1 bug in config scripts.
SolutionBoolean Fix
bool(config_value)``**int(config_value)``**config_value.lower() == "true"``**str(config_value)``**Comparison.
Do not cast. Compare the string value directly (and handle case sensitivity) to get a real boolean result.
IntermediateStrictness
int("Hello")?โ********ValueError.
Python is strict. You cannot cast "garbage" text that doesn't look like a number into an integer.
ArchitectValidation Tool
********Pydantic.
Pydantic handles type casting and validation automatically using Python type hints, preventing common errors.
MechanicsList Casting
list("Hi")?โ['H', 'i']``**["Hi"]``****[72, 105]``**['H', 'i']
Casting a string to a list splits it into individual characters. It does not wrap the whole string in a list.
MechanicsFloat Constructor
float(5)?โ********5.0
The float() constructor adds the decimal precision, turning the integer 5 into 5.0.
Use CaseFile Handling
str() when writing numbers to a text file?โ********Text files expect strings.
Functions like file.write() expect string data. You must explicitly cast numbers to strings before writing.
CoreIrreversibility
********No.
Once you cast 9.9 to int (9), the .9 is gone forever. Casting it back to float gives 9.0.
TrapComplex Types
list() to convert the string "[1, 2]" into a list?โ********No.
list() iterates over the string characters. To parse a string representation of a list, you need json.loads().
SyntaxEmpty Bool
bool("") (Empty String)?โ********False.
In Python, "empty" values like "", 0, and [] evaluate to False.
BenefitInteroperability
********Interoperability.
Type casting is the bridge that allows text from a file to be used as numbers in a calculation.
SyntaxStr Constructor
str(100)?โ********"100" (String).
This explicitly converts the integer 100 into the text format "100".
Your Final Score:
0/20 Novice
Keep practicing to reach Architect level!
**import keyword
print(keyword.iskeyword("if")) # True
# Try this:
if = 10
# Result: SyntaxError
score = 10
Score = 20
SCORE = 30
print(score, Score, SCORE)
# Result: 10 20 30 (All stored separately)
my-name = "Guru"
# Result: SyntaxError: cannot assign to operator
_)โScenario: You are writing a script to retry a server connection 5 times. You don't actually need the loop counter number (0, 1, 2...); you just need the loop to run 5 times.
_ is a valid variable name, but by convention, it means "I don't care about this value."print("--- Connection Retry Script ---")
# Using 'i' or 'count' implies we will use the number inside.
# Using '_' tells other developers: "Ignore this variable, it's just a placeholder."
for _ in range(3):
print("Connecting to Database...")
# Result:
# Connecting to Database...
# Connecting to Database...
# Connecting to Database...
# Fun Fact: '_' actually stores the last value!
print(f"The loop finished at index: {_}")
Architect Tip: This is very common in unpacking tuples too!
# We only want the IP, we don't care about the Port or Protocol
server_info = ("192.168.1.1", 8080, "TCP")
ip, _, _ = server_info
print(f"Connecting to {ip}")
.isidentifier())โScenario: You are building a Self-Service Portal where developers can type a name to create a new S3 Bucket or EC2 instance.
The Risk: If they type my-bucket (with a hyphen) or 1st_server, and you try to generate a Python variable or Class name from it dynamically, your automation will crash.
The Fix: Validate input programmatically before processing.
user_inputs = ["prod_db", "1st-database", "backup_v2", "class", "my-app"]
print("--- Validating Resource Names ---")
import keyword
for name in user_inputs:
# Check 1: Is it a valid identifier?
# Check 2: Is it a reserved keyword?
if name.isidentifier() and not keyword.iskeyword(name):
print(f"โ
'{name}' is a VALID variable name.")
else:
print(f"โ '{name}' is INVALID. Rejecting request.")
# Expected Output:
# โ
'prod_db' is a VALID variable name.
# โ '1st-database' is INVALID. (Starts with number/has hyphen)
# โ
'backup_v2' is a VALID variable name.
# โ 'class' is INVALID. (It is a keyword!)
# โ 'my-app' is INVALID. (Contains hyphen)
Scenario: Python 3 supports Unicode variables. Let's see why this is both cool and dangerous for DevOps.
# Yes, this actually runs in Python 3!
cloud = "AWS"
fire = "High Alert"
เคธเคฐเฅเคตเคฐ = "Production Server" # 'Server' written in Hindi
print(f"Deploying to {cloud} status: {fire}")
print(f"Target: {เคธเคฐเฅเคตเคฐ}")
# Architect Warning:
# Try running this script on a minimal Linux server (Alpine) inside a Docker container
# that doesn't have UTF-8 locales installed. It might CRASH or print garbage ().
# ALWAYS use standard English (ASCII) for variable names in scripts!
Scenario: You are reading a library code to fix a bug. You see variables named _internal_config and TIMEOUT. What do they mean?
# 1. Standard Variable (Snake Case) - Use for changing values
current_user = "admin"
# 2. Constant (ALL CAPS) - Use for settings that NEVER change
MAX_RETRIES = 5
API_ENDPOINT = "https://api.devsecopsguru.in"
# 3. Private Variable (Start with _) - "Don't touch this from outside"
_db_password = "secret_pass"
print(f"Connecting to {API_ENDPOINT} with user {current_user}")
# If you see ALL_CAPS in a script, you know immediately: "I should not change this line."