Welcome to your complete journey into Python programming.

Over the last two decades in IT operations, I’ve watched our field change completely. We have moved away from manual work and constant ‘firefighting’ toward a world where code runs almost everything—the era of Site Reliability Engineering. In this environment, Python isn’t just a ‘nice to have’ skill; it is the core tool we use for automation, cloud management, and security.

I wrote this handbook to give you a clear, practical path forward. The goal is to move you past just ‘running scripts’ and start building real, code-driven systems. We will start from the very beginning and go all the way to Kubernetes and DevSecOps, focusing on the actual logic you need to succeed in a modern enterprise. Your path from that first script to becoming an SRE starts right here.

Acknowledgements

Writing this manual has been a long journey, one that often took me away from the people I love. This book truly belongs to those who supported me every step of the way.

To my wife, Mrs. Vijaylaxmi Nethikar — thank you for being my rock. You took care of everything behind the scenes so I could focus on these pages. Your patience during my endless late nights at the keyboard and your belief in this project kept me going when I was exhausted. This isn't just my work; it's a reflection of the love and space you gave me to create it.

To my daughter, Dhriti — you are my greatest "Hello World." Watching you turn three while I was finishing this book reminded me of why I work so hard. Your laughter is the best break from any complex code, and I hope one day you look at this and see that you can build anything you imagine. I love you more than words, or code, could ever say.

To my beloved parents — thank you for the life and the values you gave me. To my father, Mr. Shivaji L. Nethikar, for your quiet strength, and to the memory of my mother, (Late) Mrs. Shobha Nethikar, whose blessings I feel in every achievement. Everything I am is built on the foundation you laid.

Rahul Nethikar

Website: rahulnethikar.github.io

---

DISCLAIMER & INTELLECTUAL PROPERTY RIGHTS

Copyright Notice: This publication is an original instructional work authored by Rahul Nethikar. All content within this manual—including but not limited to text, code snippets, diagrams, examples, assignments, projects, process flows, and explanations—is the sole intellectual property of the author unless otherwise stated.

Limitation of Liability & "As-Is" Software Warranty: This manual is intended exclusively for educational and professional development purposes. All code, scripts, and automation architectures provided herein are distributed on an "AS IS" basis, without warranties or conditions of any kind, whether express or implied. The author disclaims all liability for any direct, indirect, incidental, or consequential damages—including but not limited to data loss, system downtime, server failure, security breaches, or financial impact—resulting from the use, execution, or misuse of this material in any real-world, production, or commercial environment. Readers are solely responsible for testing and validating any code before deployment.

Trademarks & Affiliations: The inclusion of any logos, brands, trademarks, or product names (such as Python, Microsoft, or specific Cloud providers) is strictly for identification and educational context and remains the property of their respective owners. These references do not imply any official affiliation, endorsement, sponsorship, accuracy of representation, or real-time data usage.

Unauthorized Distribution: Plagiarism in any form—copying, paraphrasing, or reusing this content without proper credit or permission—is strictly prohibited. No part of this manual may be copied, distributed, resold, stored in a retrieval system, or transmitted in any form without the prior written consent of the author. The author reserves the right to pursue full legal action in instances of unauthorized duplication, academic dishonesty, or commercial exploitation.

---

Level: Zero to Advanced | Platform: Windows | Year: 2026

Total Number of Modules: 37 (Module 0 through Module 36)

Manual Structure

The modules follow an operational learning structure: 1. Technical Concept - Explanation of syntax in IT contexts 2. Syntax Breakdown - Analysis of keywords and symbols 3. Implementation Examples - Executable code for backend tasks 4. Project - Practical application for infrastructure management 5. Assignments - Technical exercises 6. Quiz - Knowledge assessment 7. Interview Preparation - Technical evaluation scenarios

Module Index

PART 0 — INITIAL CONFIGURATION

PART 1 — CORE SYNTAX

PART 2 — LOGIC AND CONTROL FLOW

PART 3 — DATA STRUCTURES

PART 4 — PROCEDURAL PROGRAMMING

PART 5 — OBJECT-ORIENTED ARCHITECTURE

PART 6 — SYSTEM AUTOMATION

PART 7 — INFRASTRUCTURE TOOLING

Acknowledgements

Writing this manual has been a long journey, one that often took me away from the people I love. This book truly belongs to those who supported me every step of the way.

To my wife, Mrs. Vijaylaxmi Nethikar — thank you for being my rock. You took care of everything behind the scenes so I could focus on these pages. Your patience during my endless late nights at the keyboard and your belief in this project kept me going when I was exhausted. This isn’t just my work; it’s a reflection of the love and space you gave me to create it.

To my daughter, Dhriti — you are my greatest “Hello World.” Watching you turn three while I was finishing this book reminded me of why I work so hard. Your laughter is the best break from any complex code, and I hope one day you look at this and see that you can build anything you imagine. I love you more than words, or code, could ever say.

To my beloved parents — thank you for the life and the values you gave me. To my father, Mr. Shivaji L. Nethikar, for your quiet strength, and to the memory of my mother, (Late) Mrs. Shobha Nethikar, whose blessings I feel in every achievement. Everything I am is built on the foundation you laid.

Module 00: Environment Setup

System Configuration and Verification

Objectives

Environment configuration involves: - Deployment of Python and PATH variable configuration on Windows. - Installation of Visual Studio Code and pertinent extensions. - Initialization and verification of the Python interpreter.

Python Overview

Python is a high-level, interpreted programming language utilized for automation, data processing, and infrastructure management. Key characteristics include: - Syntax clarity for maintainable codebases. - Extensibility across enterprise platforms (AWS, Azure, GCP). - Wide adoption for backend operations and DevOps CI/CD pipelines.

Section 1: Python Installation

Step 1: Distribution Acquisition

1. Open your web browser (Chrome, Edge, Firefox — any will work).

2. In the address bar at the top, type exactly:

   https://www.python.org/downloads/

3. Press Enter on your keyboard.

4. The Python website will load. You will see a big yellow button that says something like “Download Python 3.x.x” (the exact version number may vary, e.g., 3.12.3).

Step 2: Installer Execution Preparation

1. Click the large yellow download button. This downloads a file called something like python-3.x.x-amd64.exe to your computer.
2. A download progress bar will appear in your browser. Wait for it to complete (it is about 25MB, so it should take less than a minute on a normal internet connection).
3. Once done, find the file in your Downloads folder. You can press Windows Key + E to open File Explorer, then click Downloads on the left sidebar.

Step 3: Installation and PATH Configuration

Important: Select all advanced options to ensure system-wide accessibility.

1. Double-click the downloaded .exe file to run it.

2. A window will pop up titled “Install Python 3.x.x”.

3. At the bottom of this window, you will see two checkboxes:

   • [ ] Use admin privileges when installing py.exe
   • [ ] Add python.exe to PATH

4. Select the “Add python.exe to PATH” checkbox. This enables global access to the interpreter.

   PATH Variable: The PATH environment variable is a list of directories that the operating system searches to locate executable files. Correct configuration is required for terminal-based execution.

5. Click “Install Now” (the top option, which is recommended for beginners).

6. If a User Account Control (UAC) window pops up asking “Do you want to allow this app to make changes— — click Yes.

7. The installation progress bar will run. This takes 1–3 minutes.

8. When it says “Setup was successful”, click Close.

Python installation is complete.

Step 4: Installation Verification

Let’s make sure Python is working:

1. Press the Windows Key on your keyboard (the key with the Windows logo -).

2. Type cmd and press Enter. This opens the Command Prompt — a black window where you can type commands.

3. In the Command Prompt, type the following exactly and press Enter:

   python --version

4. You should see a response like:

   Python 3.12.3

5. A successful version string returned by the terminal confirms the installation status.

   If you see an error like “python is not recognized” — go back to Step 3 and make sure you checked the “Add python.exe to PATH” box. You may need to uninstall Python (via Windows Settings > Apps) and reinstall it.

   

Section 2: Visual Studio Code Configuration

VS Code Requirements

VS Code is the recommended IDE for IT operations scripts, providing: - Syntax highlighting and code folding. - Integrated terminal and debugging tools. - Extension support for cloud providers (AWS, Azure).

Step 1: Download Procedure

1. Open your browser and go to:

   https://code.visualstudio.com/

2. You will see a big blue button saying “Download for Windows”. Click it.

3. This downloads a file like VSCodeUserSetup-x64-x.xx.x.exe. Wait for the download to finish.

Step 2: Installation and PATH Verification

1. Double-click the downloaded installer file.
2. A setup wizard will open. Follow these steps:
   • License Agreement: Select “I accept the agreement” - Click Next
   • Select Destination: Leave as default - Click Next
   • Select Start Menu Folder: Leave as default - Click Next
   • Select Additional Tasks: Check “Add to PATH”, Check “Register Code as an editor for supported file types”, Check “Add ‘Open with Code’ action to Windows Explorer file context menu” - Click Next
   • Click Install
3. When complete, leave “Launch Visual Studio Code” checked and click Finish.

VS Code will open automatically.

Step 3: Python Extension Integration

Enable Python support via the Microsoft extension for IntelliSense and debugger integration.

1. Look at the left sidebar in VS Code. You will see icons. Click the one that looks like four squares (called Extensions). Or press Ctrl + Shift + X.

2. A search bar appears at the top of the sidebar. Type:

   Python

3. The first result should be “Python” by Microsoft (it will show millions of downloads and a verified checkmark).

4. Click the blue Install button next to it.

5. Wait a few seconds for it to install.

Core Extensions: | Extension Name | Publisher | Why You Need It | |—————|———–|—————–| | Python | Microsoft | Core Python support, IntelliSense, debugging | | Pylance | Microsoft | Fast, feature-rich Python language server | | Python Indent | Happy Rose | Fixes Python indentation automatically | | Code Runner | Jun Han | Run code with a single button click |

Step 4: Workspace Initialization

1. Open File Explorer (Windows Key + E).
2. Navigate to a location you like (e.g., your Desktop or Documents).
3. Right-click in an empty area - New - Folder - name it PythonProjects.
4. Go back to VS Code.
5. Click File in the top menu - Open Folder - navigate to and select your PythonProjects folder - Click Select Folder.

Step 5: Interpreter Selection

1. Press Ctrl + Shift + P to open the Command Palette.
2. Type: Python: Select Interpreter and press Enter.
3. Select the version that matches your installed Python, e.g., Python 3.12.3.
4. You will see the Python version appear in the bottom status bar of VS Code.

Section 3: Initial Script Execution

Step 1: Script Creation

1. In VS Code Explorer panel, click the New File icon next to your folder name.
2. Name the file hello_world.py and press Enter.

Step 2: Coding Implementation

In the editor, type:

print("Hello, World!")

Step 3: Script Execution

Press Ctrl + ` to open the built-in terminal, then type:

python hello_world.py

Press Enter.

Expected Output:

Hello, World!

Initial execution complete.

Syntax Analysis: print("Hello, World!")

Technical Detail: The print() function is the primary method for debugging and operational logging. Parentheses encapsulate the arguments passed to the function.

Technical Project: System Metadata Printout

print("================================")
print("       MY INTRODUCTION CARD     ")
print("================================")
print("Name    : Rahul Nethikar")
print("City    : India")
print("Goal    : Learn Python!")
print("================================")
print("Script verified.")

Assignments

Assignment 1 — Introduce Yourself

Write a Python program using multiple print() statements to display your full name, age, hometown, favorite hobby, and your goal for learning Python.

Assignment 2 — ASCII Art

Use print() to draw a simple triangle shape using * characters. You will need one print() per row.

Assignment 3 — Troubleshoot Intentional Errors

Find and fix the 3 bugs below. Write down each error message Python gives you and explain what was wrong. Use the Common Python Error Gallery below as a reference for these terminal-based execution failures.

Print("Hello World")
print('My name is Rahul)
print("I love Python!"

Knowledge Assessment

Q1. What does the .py extension tell your computer- - A) It is a photo file - B) It is a Python source code file - C) It is a PowerPoint file - D) It is a text document

Q2. What happens if you forget to check “Add Python to PATH”- - A) Python installs in the wrong folder - B) Python will only work in VS Code - C) The command python won’t be recognized in the terminal - D) Python installs twice

Q3. What is the correct Hello World program- - A) PRINT("Hello, World!") - B) print[Hello, World!] - C) print Hello, World! - D) print("Hello, World!")

Q4. What are the parentheses () used for in print("Hello")- - A) They are decorations - B) They enclose the value passed to the print function - C) They close the file - D) They are part of the text

Q5. Which is the official Python download website- - A) python.com - B) python.org - C) python.net - D) getpython.com

Technical Interview Preparation

Interview Q1:

“How do you verify Python is installed correctly on Windows—

Ideal Answer: Open Command Prompt and type python --version. If Python is installed and on the PATH, it responds with the version number (e.g., Python 3.12.3). An error means Python isn’t installed or wasn’t added to PATH.

Interview Q2:

“What is the purpose of adding Python to the system PATH variable—

Ideal Answer: PATH is an environment variable listing directories Windows searches for executables. Adding Python to PATH lets you type python in any terminal window and have it work without typing the full installation path each time.

Interview Q3:

“What is the difference between a code editor like VS Code and an IDE like PyCharm—

Ideal Answer: VS Code is a lightweight, extensible text editor — you add capabilities via extensions. PyCharm is an all-in-one IDE pre-loaded with Python-specific tools (debugger, refactoring, test runner) out of the box. VS Code is faster and more flexible; PyCharm is heavier but more complete for Python-only work.

Module Summary

Operational Insight

“Environment setup is the first hurdle. If you can’t run ‘Hello World’, you can’t build a cloud. Get the PATH right once, and the rest is engineering.”

Next: Module 1 — Introduction to Python

Module 01: Introduction to Python

Interpreter Architecture, REPL, and Commenting Standards

Objectives

Successful completion of this module includes: - Assessment of Python’s role in modern infrastructure. - Utilization of the Read-Eval-Print Loop (REPL) for command testing. - Implementation of standardized code commenting. - Analysis of sequential code execution and indentation blocks.

Python’s versatility makes it the primary choice for modern IT infrastructure.

Python is an interpreted, high-level, general-purpose programming language. Developed by Guido van Rossum and released in 1991, it has become a standard for system administration and backend automation.

Operational Features

The Python REPL (Interactive Shell)

REPL stands for Read-Eval-Print Loop. It’s a live Python session where you type one line, press Enter, and Python immediately responds.

The REPL provides an interactive environment for testing code snippets without requiring a saved file. Each input is read and evaluated immediately.

How to Open the REPL:

1. Open Command Prompt (Windows Key - type cmd - Enter)
2. Type python and press Enter
3. You’ll see >>> — the prompt, Python is waiting for you

Try These in the REPL:

>>> 2 + 2
4
>>> print("Python is awesome!")
Python is awesome!
>>> 10 * 5
52
>>> exit()

Comments: Documentation within Code

A comment is a line Python completely ignores — it exists only for humans to read.

Comments are lines ignored by the interpreter. They are used for code documentation and temporary deactivation of logic.

Single-Line Comment

# This is a comment. Python ignores this line entirely.
print("Hello!")  # This comment explains the print statement

Syntax Breakdown: # This is a comment

Multi-Line Comment

"""
This is a multi-line comment.
It can span as many lines as you want.
Python stores it as a string but it has no effect on execution.
"""
print("This line runs normally.")

Code Execution Flow

Python reads your .py file from top to bottom, one line at a time:

print("Line 1 runs first")
print("Line 2 runs second")
print("Line 3 runs third")

Output:

Line 1 runs first
Line 2 runs second
Line 3 runs third

Execution Note: Python processes files sequentially. Logical ordering is required to ensure dependencies are initialized before use.

Indentation: Scope Definition

Indentation (the spaces at the beginning of a line) is part of the language syntax, not just style. It defines which lines belong to which block.

# Correct:
if True:
    print("This is indented — it belongs to the if block")

# WRONG — will cause an IndentationError:
if True:
print("This has no indentation — Python will crash!")

Scope Rule: Indentation defines logical blocks. Lines sharing the same indentation level belong to the same execution scope. Incorrect indentation results in an IndentationError.

Rule: Use 4 spaces per indentation level. VS Code handles this automatically when you press Tab.

Technical Exercise: System Metadata Script

# =============================================
# PROJECT: About Me

# =============================================

print("========================================")
print("         ABOUT ME - PYTHON PROGRAM      ")
print("========================================")
print("Hello! My name is Rahul Nethikar.")
print("I am learning Python programming.")
print("My favorite quote:")
print('"The journey of a thousand miles begins with one step."')
print("========================================")
print("Thank you for reading!")

Syntax Breakdown for '"The journey..."': - Outer single quotes '...' wrap the string - Inside " characters are printed literally - This is one way to include quote marks inside a string

Assignments

Q1. What does REPL stand for- - A) Run Every Python Line - B) Read-Eval-Print Loop - C) Repeat Execute Print Logic - D) Runtime Engine for Python Language

Q2. How does Python mark a line as a comment- - A) // at the start - B) /* */ around text - C) # at the start - D) -- at the start

Q3. In what order does Python execute lines in a file- - A) Bottom to top - B) Random order - C) Top to bottom, line by line - D) Alphabetically

Q4. What is Python’s indentation rule- - A) Only for aesthetics - B) Mandatory — defines code blocks syntactically - C) Must use tabs, never spaces - D) Only matters inside functions

Q5. Who created Python- - A) Bill Gates - B) Linus Torvalds - C) Happy Gosling - D) Guido van Rossum

Technical Evaluation Preparation

Q1: “Is Python interpreted or compiled—

Ideal Answer: Python is interpreted — code is read and executed line by line at runtime. Compiled languages (like C++) translate all code to machine code before execution. Python is more interactive and faster to develop in, but generally slower for heavy computation. Python does compile to bytecode internally (.pyc files), but this is transparent to the developer.

Q2: “What is PEP 8—

Ideal Answer: PEP 8 is Python’s official style guide (PEP = Python Enhancement Proposal). It defines conventions: 4-space indentation, 79-character line limit, snake_case for variables, PascalCase for classes. It matters because code is read far more than it’s written — consistent style makes collaboration and maintenance far easier.

Q3: “What is the difference between Python 2 and Python 3—

Ideal Answer: Python 2 reached end-of-life on January 1, 2020. Key differences: print was a statement in Python 2 (print 'hello') vs. a function in Python 3 (print('hello')). Python 3 handles Unicode natively, introduced f-strings, type hints, async/await. Always use Python 3 for any new project.

Module 02: Variables & Data Types

Memory Allocation and Object Typing

Objectives

Module competency requires: - Variable initialization and value assignment. - Analysis of core object types: int, float, str, bool. - Utilization of the type() built-in function for runtime inspection. - Assessment of dynamic typing behavior.

Variable Initialization

A variable is a symbolic name that references an object in memory. Assigning a value to a variable establishes a binding between the name and the data object.

In Python, you create a variable by giving it a name and assigning a value using =:

name = "Rahul"
age = 25
height = 5.9
is_student = True

Syntax Breakdown: name = "Rahul"

Assignment Note: The = operator is used for assignment, not equality. It binds the value on the right-hand side to the identifier on the left-hand side. Equality checking is performed via the == operator (see Module 3).

Identifier Naming Conventions

Core Data Types

Python’s standard library includes four primary scalar data types.

1. int (Integer)

Used for whole numbers without fractional components. Operational examples include server port numbers or process IDs.

age = 25
year = 2026
temperature = -10
bank_balance = 0

2. float (Floating Point)

Used for numbers requiring decimal precision. Operational examples include CPU load averages or memory utilization percentages.

height = 5.9
price = 299.99
pi = 3.14159
tax_rate = 0.18

3. str (String)

Sequence of characters enclosed in quotes. Used for storing log entries, hostnames, or file paths.

first_name = "Rahul"
greeting = 'Hello, World!'
sentence = "I have 3 cats"   # Numbers inside quotes are still strings
empty = ""                   # An empty string

Analogy: A string is like a necklace of characters. Each letter, space, or symbol is a bead, strung together in order.

Syntax Breakdown: greeting = 'Hello, World!'

You can use either single (') or double (") quotes. Always close what you open.

3. str (String)

Sequence of characters enclosed in quotes. Used for storing log entries, hostnames, or file paths.

first_name = "Rahul"
greeting = 'Hello, World!'
sentence = "I have 3 cats"
empty = ""

4. bool (Boolean)

Binary value representing truth states: True or False. Used for conditional logic and status flags (e.g., service status).

is_logged_in = True
has_passed_exam = False
is_raining = True

Logic Note: Boolean literals must be capitalized. true or false (lowercase) will trigger a NameError. Python is case-sensitive regarding logical constants.

Object Inspection using type()

You can ask Python “what kind of data is this— using type():

age = 25
print(type(age))       # <class 'int'>

price = 9.99
print(type(price))     # <class 'float'>

name = "Rahul"
print(type(name))      # <class 'str'>

is_open = True
print(type(is_open))   # <class 'bool'>

Syntax Breakdown: print(type(age))

This is called nesting functions — one function inside another. Python evaluates the inner one first.

Dynamic Typing Analysis

Python employs dynamic typing, allowing a single identifier to reference objects of different types during execution.

Python is dynamically typed — a variable can hold different types at different times:

x = 10          # x is an int
print(type(x))  # <class 'int'>

x = "hello"     # Now x holds a string
print(type(x))  # <class 'str'>

x = 3.14        # Now x holds a float

print(type(x)) # <class ‘float’>

***

## Technical Project: Server Resource Monitor Script

```python
# ============================================
# PROJECT: Server Resource Monitor

# ============================================

hostname = "db-server-01"
uptime_days = 45
cpu_utilization = 12.5
is_healthy = True

print("====== RESOURCE REPORT ======")
print("Host      :", hostname)
print("Uptime    :", uptime_days)
print("CPU       :", cpu_utilization)
print("Healthy   :", is_healthy)
print("Type Host :", type(hostname))
print("Type CPU  :", type(cpu_utilization))
print("=============================")

Output:

====== RESOURCE REPORT ======
Host      : db-server-01
Uptime    : 45
CPU       : 12.5
Healthy   : True
Type Host : <class 'str'>
Type CPU  : <class 'float'>
=============================

Assignments

Assignment 1: Infrastructure Variables

Create identifiers for a server instance: server_name (str), ram_gb (int), storage_tb (float), and is_active (bool). Print the value and type() for each identifier.

Assignment 2: Log Entry Simulation

Initialize variables for a log file path (str), a response time (float), and an error flag (bool). print a structured log summary using these variables.

Assignment 3 — Variable Reassignment Experiment

Start with x = 100. Print it and its type. Reassign to x = "Python", print again. Reassign to x = False, print again. Write a comment above each step explaining what is happening and why Python allows it.

Knowledge Assessment

Q1. What symbol assigns a value to a variable in Python- - A) == - B) := - C) = - D) ->

Q2. Which is a valid Python variable name- - A) 2myvar - B) my-var - C) my var - D) my_var

Technical Interview Preparation

Q1: “What is the difference between statically and dynamically typed languages—

Ideal Answer: Statically typed languages (Java, C#) require declaring a variable’s type at creation — it cannot change. Dynamically typed languages like Python infer type from the assigned value, and it can change freely. Python’s dynamic typing speeds up development but can cause type-related bugs that statically typed languages catch at compile time.

Q2: “What is the difference between int and float- When would you use each—

Ideal Answer: int stores whole numbers (no decimal), e.g., 5, -3. float stores decimal numbers, e.g., 3.14, -0.5. Use int for countable, indivisible things (students, pages). Use float for measurements (price, temperature, weight). Note: floats have precision limitations (0.1 + 0.2 = 0.30000000000000004) — for financial math, use Python’s decimal module.

Q3: “What is None in Python—

Ideal Answer: None is a special keyword representing the absence of a value — its own type: NoneType. Used when a variable exists but has no meaningful value yet, or when a function returns nothing. Always use is None rather than == None because is checks object identity, which is the correct comparison for None.

Operational Insight

“Variables aren’t just labels; they are the memory pointers of your application. Professional code uses clear, snake_case names that reveal intent.”

Module 03: Operators & Expressions

Computational Logic, Comparison Operations, and Boolean Control

Objectives

Module competency requires: - Implementation of arithmetic operators for data processing. - Application of comparison operators for value validation. - Utilization of logical operators for complex conditional gating. - Analysis of operator precedence in nested expressions. - Utilization of compound assignment operators.

Operators in Python

Operators are functional symbols used to perform computations on operands. An operator combined with operands constitutes an expression, which the interpreter evaluates to a single value.

The values on either side of an operator are called operands. Together, an operator + operands form an expression.

  5    +    3
  -         -
operand  operand
     -
  operator

Arithmetic Operators

These perform mathematical calculations — just like a calculator.

Arithmetic operators facilitate mathematical transformations. Operational applications include calculating memory offsets, disk space availability, or network throughput.

a = 10
b = 3

print(a + b)   # 13  — addition
print(a - b)   # 7   — subtraction
print(a * b)   # 30  — multiplication
print(a / b)   # 3.3333333333333335 — true division, always returns float
print(a // b)  # 3   — floor division, drops the decimal (rounds DOWN)
print(a % b)   # 1   — remainder after dividing (10 = 3×3 + 1)
print(a ** b)  # 1000 — 10 to the power of 3

Syntax Breakdown: print(a // b)

Operational Example (// and %): If a script processes 10 tasks across 3 concurrent threads, 10 // 3 = 3 represents the baseline tasks per thread, while 10 % 3 = 1 represents the remaining tasks to be queued sequentially.

Comparison Operators

Comparison operators compare two values and always return either True or False.

Comparison operators assess the relationship between two operands, returning a boolean True or False. They are foundational to control flow and data validation.

x = 10
y = 5

print(x == y)   # False — 10 is not equal to 5
print(x != y)   # True  — 10 is not equal to 5
print(x > y)    # True  — 10 is greater than 5
print(x < y)    # False — 10 is not less than 5
print(x >= 10)  # True  — 10 is equal to 10 (>= includes equality)
print(y <= 3)   # False — 5 is not less than or equal to 3

Syntax Breakdown: print(x == y)

• Critical mistake beginners make:

x = 5    # Assignment: "store 5 in x"
x == 5   # Comparison: "is x equal to 5— - True

Single = assigns. Double == compares. Never confuse them.

Logical Operators

Logical operators combine multiple comparisons into one bigger condition.

Logical operators consolidate multiple boolean expressions into localized conditional gates. - and: Evaluates to True only if all expressions are true. - or: Evaluates to True if at least one expression is true. - not: Inverts the boolean value.

age = 20
has_id = True
has_ticket = False

# 'and' — both conditions must be True
print(age >= 18 and has_id)      # True and True - True
print(age >= 18 and has_ticket)  # True and False - False

# 'or' — at least one condition must be True
print(has_id or has_ticket)      # True or False - True
print(age < 18 or has_ticket)    # False or False - False

# 'not' — flips the boolean
print(not has_ticket)            # not False - True
print(not has_id)                # not True - False

Syntax Breakdown: print(age >= 18 and has_id)

Truth Table for and and or:

Assignment Operators (Shorthand)

These update a variable’s value in a compact way:

score = 100
print(score)    # 100

score += 50     # Add 50 to score
print(score)    # 150

score -= 20     # Subtract 20
print(score)    # 130

score *= 2      # Multiply by 2
print(score)    # 260

Syntax Breakdown: score += 50

Operator Precedence

Python enforces a strict order of operations (standard PEMDAS/BODMAS rules). Logic evaluation priority is as follows:

# Without parentheses — follows precedence
result = 2 + 3 * 4        # - 2 + 12 - 14 (not 20!)
print(result)             # 14

# With parentheses — parentheses always go first
result = (2 + 3) * 4      # - 5 * 4 - 20
print(result)             # 20

Performance Note: Use parentheses to enforce evaluation order and improve code readability, even when standard precedence applies.

Technical Project: Resource Utilization Audit Script

# ============================================
# PROJECT: Instance Resource Audit
# ============================================
# Task: Cloud Infrastructure Bill Calculation
compute_cost = 250.0
storage_cost = 180.0
network_cost = 320.0
tax_rate = 0.18

subtotal = compute_cost + storage_cost + network_cost
tax_amount = subtotal * tax_rate
total_bill = subtotal + tax_amount

threshold_alert = total_bill > 500

print("====== CLOUD INFRASTRUCTURE BILL ======")
print("Compute (EC2)  :", compute_cost)
print("Storage (S3)   :", storage_cost)
print("Network (DT)   :", network_cost)
print("-----------------------------")
print("Subtotal       :", subtotal)
print("Tax (VAT 18%)  :", tax_amount)
print("TOTAL BILL     :", total_bill)
print("============================")
print("Bill > $500    :", threshold_alert)
print("Threshold Alert:", threshold_alert)

Output:

====== CLOUD INFRASTRUCTURE BILL ======
Compute (EC2)  : 250.0
Storage (S3)   : 180.0
Network (DT)   : 320.0
-----------------------------
Subtotal       : 750.0
Tax (VAT 18%)  : 135.0
TOTAL BILL     : 885.0
============================
Bill > $500    : True
Threshold Alert: True

Assignments

Assignment 1: Disk Quota Calculator

Initialize variables for total_disk_space_gb and used_disk_space_gb. Calculate the percentage utilized and a boolean flag alert_required that evaluates to True if utilization exceeds 85% or if remaining space is less than 5GB.

Assignment 2 — Even or Odd Detector

Assign any integer to a variable number. Use the % (modulus) operator to check if the number is even or odd. Print both number % 2 and whether number % 2 == 0. Explain in comments what the result proves.

Assignment 3 — Compound Expression Evaluator

Without running the code first, predict the output of each line below. Then run the code and check if you were right. Write a comment for any you got wrong explaining why:

print(2 + 3 * 4)
print((2 + 3) * 4)
print(10 / 3)
print(10 // 3)
print(10 % 3)
print(2 ** 8)
print(True and False or True)
print(not True or False)

Knowledge Assessment

Q1. What does the // operator do in Python- - A) Regular division, returns a float - B) Floor division — divides and drops the decimal - C) Calculates the remainder - D) Raises to a power

Q2. What is the result of 10 % 3- - A) 3 - B) 3.33 - C) 1 - D) 0

Technical Interview Preparation

Q1: “What is the difference between / and // in Python—

Ideal Answer: > “/ is true division — it always returns a float, even if the result is a whole number (e.g., 10 / 2 - 5.0). // is floor division — it divides and rounds down to the nearest whole integer, always returning an int when both operands are integers (e.g., 10 // 3 - 3, 7 // 2 - 3). Floor division is useful for things like splitting items into groups where you can’t have fractions.”

Q2: “What does the modulus operator % do, and give a real-world use case.”

Ideal Answer: > “The % operator returns the remainder after integer division. For example, 10 % 3 - 1 because 10 divided by 3 is 3 with a remainder of 1. Real-world uses: (1) Even/odd checking — n % 2 == 0 means n is even. (2) Cycling through values — index % list_length keeps an index within bounds, useful for circular buffers or carousels. (3) Time calculations — minutes % 60 gives remaining minutes after extracting hours.”

Q3: What is short-circuit evaluation-

Ideal Answer: > “Python uses short-circuit evaluation for and and or. For and, if the left side is False, Python doesn’t evaluate the right side — because the overall result must be False regardless. For or, if the left side is True, Python skips the right side — because the result must be True regardless. This matters for performance and for safety: for example, if list and list[0] == 'x' — if list is empty (falsy), Python never evaluates list[0], avoiding an IndexError.”

Module 04: User Input & Type Casting

Data Ingestion, String Buffers, and Type Conversion

Objectives

Successful completion of this module includes: - Implementation of the input() function for data acquisition. - Analysis of the default string return type of the input() buffer. - Execution of type casting: int(), float(), and str() conversions. - Development of a functional data transformation script. - Mitigation of ValueError exceptions during type conversion.

Data Acquisition Workflow

Modern automation requires robust data ingestion patterns. Interactive scripts utilize the input-process-output cycle to transform user-provided parameters into executable logic.

graph TD
    A[Initialization] --> B[Prompt Display]
    B --> C[Stdin Read]
    C --> D[String Buffer Allocation]
    D --> E{Numeric Transformation Required-}
    E -- Yes --> F[Type Casting: int/float]
    E -- No --> G[String Object Retention]
    F --> H[Data Processing]
    G --> H
    H --> I[Stdout Write]

The input() Function

The input() function pauses script execution and waits for data from the standard input stream (stdin).

Input Buffer Persistence

The input() function inherently returns a str object. Even when numeric characters are provided, the interpreter treats them as text.

system_load = input("Enter current system load: ")
print(type(system_load))  # Returns: <class 'str'>

Type Casting Strategy

Type casting is the explicit conversion of one data type into another. This is necessary for performing arithmetic operations on ingested data or formatting numeric output for string concatenation.

Type Conversion Standards

1. int() - Transforms compatible strings or floats to integers.
2. float() - Transforms compatible strings or integers to floating-point objects.
3. str() - Transforms numeric types into string objects.

Implementation: Parameter Parsing

# Improper Ingestion (Concatenation Bias)
num1 = input("Port ID: ")      # Submits "80"
num2 = input("Offset: ")       # Submits "5"
print(num1 + num2)             # Output: "805" (Logical Error)

# Proper Ingestion (Casting)
num1 = int(input("Port ID: "))
num2 = int(input("Offset: "))
print(num1 + num2)             # Output: 85 (Arithmetic Correctness)

Syntax Breakdown: int(input("..."))

Implementation Constraints

1. Literal Incompatibility

Casting a float-represented string directly to an int will trigger a ValueError.

threshold = int("49.99")  # Target Failure: ValueError

Resolution: Convert to float before casting to int if truncation is required.

2. Concatenating Numbers and Strings

You cannot “add” a string and a number without converting:

age = 25
print("I am " + age + " years old.")  #  TypeError
# Fix:
print("I am " + str(age) + " years old.")
# OR even better (f-strings):
print(f"I am {age} years old.")

Visual Studio Code Debugging

For self-study practitioners, mastering the debugger is the single most important skill for independence.

Operational Insight

“Input and casting are where your scripts first encounter the ‘Real World’ — and the real world provides bad data. Never trust user input without verification. We will revisit this in the Error Handling module, but for now, always think about what happens if the user types ‘ABC’ into your port number field.” ***

Technical Project: Resource Provisioning Calculator

Calculate infrastructure scaling requirements based on user parameters.

# ============================================
# PROJECT: Instance Provisioning Tool
# ============================================

# Data Acquisition
instance_count = int(input("Enter required instance count: "))
ram_per_instance = float(input("Enter RAM per instance (GB): "))
storage_per_instance = float(input("Enter Storage per instance (GB): "))

# Computation
total_ram = instance_count * ram_per_instance
total_storage = instance_count * storage_per_instance

# Output Generation
print("----------------------------")

Assignments

Assignment 1: Infrastructure Inventory Parser

Request user input for server_hostname, cpu_count, uptime_seconds, and is_production (True/False). - Calculate uptime_days. - Output a structured system report using string formatting.

Assignment 2: Storage Unit Converter

Accept user input for a file size in Gigabytes (GB). - Perform conversions to Megabytes (MB) and Terabytes (TB). - Print the results as float values.

Knowledge Assessment

Q1. What is the default return type of the input() function- - A) str - B) float - C) int - D) input

Technical Evaluation Preparation

Q1: “Why does Python require explicit type casting for inputs—

Ideal Answer: > “Python is a strongly typed language, meaning it won’t automatically assume a string containing numbers should be treated as a number. The input() function returns a string to be safe and versatile (since a user could type letters, symbols, or numbers). Requiring explicit casting (like int() or float()) forces the developer to define exactly how the data should be handled, preventing accidental errors like adding a name to a salary.”

Q2: “What is the difference between str(10) and 10—

Ideal Answer: > “10 is an integer literal, used for mathematical calculations. '10' (the result of str(10)) is a string literal, used for text manipulation. You can use '10' * 3 to get '101010', but 10 * 3 gives 30. Casting allows us to move between these two ‘worlds’ depending on whether we need to calculate or display.”

Q3: “How can you handle a scenario where a user enters ‘abc’ when you expect a number—

Ideal Answer: > “If we use int(input()) and the user enters text, Python will throw a ValueError. To handle this professionally, we use a try...except block. We ‘try’ the conversion, and if it fails, the ‘except’ block catches the error and allows us to print a friendly message like ‘Invalid input, please enter a number’ instead of letting the program crash.”

Module 05: Strings In Depth

String Buffer Management, Slicing, and Formatting Standards

Objectives

Module competency requires: - Management of string objects and character sequences. - Implementation of indexing and slicing for data extraction. - Utilization of string methods for data normalization and parsing. - Application of f-string literals for standardized output formatting. - Management of escape sequences within character buffers. - Development of a system log parsing utility.

String Logic

In Python, a String is a sequence of characters stored as an immutable object. Immutability ensures that the underlying character buffer cannot be modified post-initialization; transformations require the creation of new string objects. Operational examples include processing hostnames, log entries, or file paths.

Creating Strings:

single_quote = 'Hello'
double_quote = "Python"
triple_quote = """This is a
multi-line string."""  # Used for long paragraphs or documentation

Indexing and Slicing

Since a string is an ordered sequence, Python assigns every character a “position number” called an Index.

1. Indexing (Accessing one character)

• Forward Indexing: Starts at 0.
• Backward (Negative) Indexing: Starts at -1.

text = "Python"
print(text[0])   # Output: 'P'
print(text[-1])  # Output: 'n' (The last character)

2. Slicing (Accessing a range)

Syntax: string[start : stop : step] - start: Index where the slice begins (inclusive). - stop: Index where the slice ends (exclusive � it stops just before this). - step: Optional; how many characters to jump.

path = "/var/log/syslog"
print(path[0:4])    # "/var"
print(path[5:8])    # "log"
print(path[::-1])   # Reverses for buffer analysis

Common String Methods

Python provides “built-in tools” (methods) to modify how text looks.

String Formatting (f-strings)

The modern and fastest way to inject variables into text is using f-strings (formatted string literals).

# Standard f-strings
print(f"Server {name} reported status: {score}%") 

Note: Just put an f before the starting quote and use {} for variables.

Escape Characters

What if you want to put a quote inside a quote- Or start a new line-

• \n � New Line
• \t � Tab space
• \' � Single Quote
• \" � Double Quote
• \\ � Backslash

print("Line 1\nLine 2")
print("He said, \"Python is awesome!\"")

Technical Project: System Log Parser

Develop a script to normalize and format raw system log data.

# ============================================
# PROJECT: System Log Normalizer
# ============================================

# Raw input simulation
raw_log = "  ERROR: Connection timeout on server: DB-PROD-01 at 12:00:05  "

# Data Normalization
clean_log = raw_log.strip()
alert_type = clean_log.split(":")[0].upper()
server_details = clean_log.split(":")[1].split("at")[0].strip()

# Formatted Output
formatted_report = f"""
------------------------------------------
LOG STATUS: {alert_type}
HOST      : {server_details}
CLEAN LOG : {clean_log}
------------------------------------------
"""

print(formatted_report)

Assignments

Assignment 1: Hostname Invalidator

Accept user input for a hostname. - Print the hostname length. - Print a masked version of the hostname where all characters except the first and last are replaced with -.

Assignment 2: Access Log Filter

Accept a raw CSV-style log string (e.g., 2026-03-17,DB-SRV,ACTIVE). - Use .split() to extract the service status. - Print the status in uppercase.

Knowledge Assessment

Q1. What is the result of "Python"[1:4]- - A) Pyt - B) yth - C) ytho - D) pyth

Q2. Which method removes spaces from both ends of a string- - A) clean() - B) cut() - C) strip() - D) split()

Q3. How do you reverse a string s using slicing- - A) s[0:-1] - B) s[1:0] - C) s[::-1] - D) s[-1:0]

Q4. What character is used to start an f-string- - A) s - B) f - C) r - D) $

Q5. True or False: Strings in Python are mutable. - A) True - B) False (They are immutable)

Technical Evaluation Preparation

Q1: “What is the difference between a shallow copy and a string slice�

Ideal Answer: > “In Python, strings are immutable. When you take a slice like s[1:5], Python creates an entirely new string object in memory containing those characters. It doesn’t modify the original string.”

Q2: “When would you use split() vs join()�

Ideal Answer: > “split() is used to turn a single string into a List of substrings (e.g., breaking a sentence into words). join() is the opposite; it takes a List of strings and merges them into one single string with a specific separator (like a comma or space) between them.”

Q3: “What is string interning in Python�

Ideal Answer: > “String interning is an optimization where Python stores only one copy of certain identical strings in memory. This saves space and makes comparisons faster (since it can compare memory addresses instead of character-by-character). It usually happens automatically for short, constant strings.”

Assignment Solution Key

1. Password Masker

pwd = input("Enter password: ")
masked = pwd[0] + ("*" * (len(pwd)-2)) + pwd[-1]
print(f"Length: {len(pwd)}, Masked: {masked}")

2. Palindrome Checker

word = input("Enter word: ").lower()
print(word == word[::-1])

3. URL Cleaner

url = "   www.GOOGLE.com/search   "
clean_url = url.strip().lower().replace("google", "bing")
print(clean_url)

Module 06: Conditional Statements

Control Flow, Boolean Evaluation, and Branching Logic

Objectives

Module competency requires: - Critical analysis of Boolean expressions. - Implementation of if, elif, and else constructs for control flow. - Management of nested conditional branching. - Application of logical operators (and, or, not) for compound logic. - Utilization of the Ternary Operator for localized logic. - Development of a multi-parameter health monitoring script.

Flow Control Overview

Conditional statements allow a program to execute specific code blocks based on the evaluation of boolean expressions. This branching logic is essential for managing dynamic operational environments�such as server-side permissions, infrastructure scaling, and automated alerting.

The if Statement

The if statement evaluates a condition. If the condition is True, the code inside the block runs.

age = 20

if age >= 18:
    print("You are an adult.")
    print("You can vote!")  # Notice the indentation!

Indentation Constraints

Python utilizes whitespace to define executable blocks. Code belonging to a conditional branch must be consistently indented. Failure to maintain uniform indentation results in an IndentationError.

Multi-Branch Logic (elif and else)

What if the first condition is False- We use elif (else if) for more checks, and else as a final fallback.

score = 85

if score >= 90:
    print("Grade: A")
elif score >= 80:
    print("Grade: B")
elif score >= 70:
    print("Grade: C")
else:
    print("Grade: F (Fail)")

Nested Conditional Branching

You can put an if statement inside another if statement. This is useful for “multi-layered” decisions.

# Sub-logic example: User Authorization
if is_authenticated:
    print("User globally authenticated.")
    if is_admin:
        print("Privileged access granted to secure terminal.")
    else:
        print("Regular user access level applied.")
else:
    print("Authentication required.")

Compound Logical Operators (and, or, not)

Instead of nesting, you can merge conditions into a single line for cleaner code.

# User access validation
if username == "sysadmin" and access_key == "9yX$2":
    print("Administrative Access Granted")
else:
    print("Access Denied: Invalid Credentials")

The Ternary Operator

Need a simple if...else on one line- The Ternary Operator is your best friend.

Syntax: output_if_true if condition else output_if_false

num = 10
status = "Even" if num % 2 == 0 else "Odd"
print(status)  # Output: Even

Technical Project: Service Health Monitoring Tool

Simulate an automated threshold monitor for localized system health reporting.

# ============================================
# PROJECT: Automated Health Monitor
# ============================================

# Step 1: Collect Telemetry
server_id = input("Enter server identifier: ").upper()
cpu_usage = float(input("Enter CPU utilization %: "))
disk_usage = float(input("Enter Disk utilization %: "))

# Step 2: Gated Logical Evaluation
if cpu_usage > 100 or cpu_usage < 0:
    print("Error: Invalid telemetry data received.")
else:
    if cpu_usage >= 90 or disk_usage >= 95:
        status = "CRITICAL"
        alert_level = "P1"
    elif cpu_usage >= 75 or disk_usage >= 80:
        status = "WARNING"
        alert_level = "P2"
    else:
        status = "HEALTHY"
        alert_level = "NONE"

print("-----------------------------------")

Assignments

Assignment 1: Request Status Classifier

Accept an HTTP response code (e.g., 200, 404, 500). - Categorize as “Success” (200-299), “Client Error” (400-499), or “Server Error” (500+).

Assignment 2: Access Tier Optimization

Accept a user’s subscription level and data usage. - If usage > 50GB and tier is “FREE”, output “Throttling Required”. - Otherwise, output “Standard Throughput Enabled”.

Assignment 3 � Leap Year Checker

A year is a leap year if: - It is divisible by 4. - BUT if it’s divisible by 100, it must also be divisible by 400. Write a program to check if a year is a leap year.

Knowledge Assessment

Q1. Which keyword is used for the “fallback” if all other conditions fail- - A) elif - B) if - C) else - D) stop

Q2. What is the result of (True or False) and not(False)- - A) False - B) True - C) None - D) Error

Q3. What will happen if you don’t indent code inside an if statement- - A) It runs normally - B) It raises an IndentationError - C) It is ignored - D) It raises a ValueError

Q4. What is the symbolic shortcut for elif in some other languages, which Python combines into one word- - A) else if - B) elif - C) ifelse - D) case

Q5. When using and, what happens if the first condition is False- - A) Python checks the second condition - B) Python skips the second condition (Short-circuiting) - C) The program crashes - D) It depends on the else block

Technical Evaluation Preparation

Q1: “What is short-circuit evaluation in Python�

Ideal Answer: > “Short-circuiting happens with and and or. In an and expression, if the first part is False, the whole thing must be False, so Python doesn’t even look at the second part. In an or expression, if the first part is True, the whole thing is True, so the second part is skipped. This makes programs slightly faster and prevents errors in the second condition.”

Q2: “Can you use multiple else blocks for one if statement�

Ideal Answer: > “No. An if statement can have multiple elif blocks, but it can only ever have one else block. The else block acts as the final ‘catch-all’ for anything that didn’t match the previous conditions.”

Q3: “What is the difference between == and is�

Ideal Answer: > “== checks for equality (do they have the same value-). is checks for identity (are they the exact same object in memory-). For comparing numbers or strings in conditions, you should always use ==. is is mostly used for comparing variables against None.”

Assignment Solution Key

1. Number Classifier

num = int(input("Enter number: "))
if num > 0:
    parity = "Even" if num % 2 == 0 else "Odd"
    print(f"Positive and {parity}")
elif num < 0:
    print("Negative")
else:
    print("Zero")

2. Cinema Ticket Pricing

age = int(input("Age: "))
day = input("Day: ").lower()

if age < 5: price = 0
elif 5 <= age <= 12: price = 150
elif 13 <= age <= 60: price = 300
else: price = 200

if day == "wednesday" and price > 0:
    price -= 50

print(f"Total Price: -{price}")

3. Leap Year Checker

year = int(input("Year: "))
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print("Leap Year")
else:
    print("Not a Leap Year")

Module 07: Iteration Control - for & while

Automated Execution, Range Logic, and Loop Control Structures

Objectives

Module competency requires: - Assessment of iteration logic for task automation. - Implementation of for loops for sequence traversal. - Implementation of while loops for conditional execution. - Utilization of loop control flow directives: break, continue, and pass. - Analysis and mitigation of infinite loop scenarios. - Development of an automated connection retry utility.

Iteration Logic

Iteration is the process of executing a block of code repeatedly. This is essential for managing bulk data operations, such as iterating through a list of server hostnames, processing log entries, or polling an API until a specific status is returned.

There are two primary iteration constructs in Python: definite (for) and indefinite (while) loops.

The for loop & range()

The for loop is utilized when the number of iterations is known or can be derived from a sequence. The range() function is standard for generating a sequence of integers.

Syntax of range():

range(start, stop, step) - start: (Optional) Defaults to 0. - stop: (Required) The loop stops before reaching this number. - step: (Optional) How many numbers to skip.

# Print numbers from 1 to 5
for i in range(1, 6):
    print(f"Number: {i}")

# Print even numbers from 2 to 10
for x in range(2, 11, 2):
    print(x)

The while loop

A while loop executes as long as a specified boolean condition remains True. This is used for indefinite iteration where the end state is determined by runtime data.

count = 1
while count <= 5:
    print(f"Count is: {count}")
    count += 1  # - CRITICAL: Increment the variable or the loop runs forever!

Loop Overflow: Infinite Iteration

If a while condition never evaluates to False, the script will consume CPU cycles indefinitely. In a terminal environment, these processes must be force-terminated (standard interrupt: Ctrl + C).

Loop Control Flow (break, continue, pass)

Sometimes we need to change how a loop behaves midway.

# Using break
for n in range(1, 10):
    if n == 5:
        break  # Loop stops at 4
    print(n)

# Using continue
for n in range(1, 6):
    if n == 3:
        continue  # Skips 3, prints 1, 2, 4, 5
    print(n)

Nested Iteration

Loops can be nested to manage multi-dimensional data structures. Operational examples include scanning nested directory structures or iterating through multi-region cloud resources.

for row in range(1, 4):
    for col in range(1, 4):
        print(f"({row}, {col})", end=" ")
    print() # New line after each row

Technical Project: Automated Connection Retry Script

Develop a utility that attempts to establish a connection with a maximum retry limit.

# ============================================
# PROJECT: Automated Retry Logic
# ============================================
import random
import time

max_retries = 5
is_connected = False

print("--- Initializing Network Connection ---")

for attempt in range(1, max_retries + 1):
    print(f"Connection attempt {attempt}/{max_retries}...")
    
    # Simulate connectivity check
    success_seed = random.randint(1, 10)
    
    if success_seed > 7:  # Simulate 30% success rate
        print("Connected successfully.")
        is_connected = True
        break
    else:
        print("Connection failed. Retrying...")
        time.sleep(1) # Wait 1 second before next attempt

if not is_connected:
    print("\nCritical Error: Maximum retry limit reached. Connection timed out.")

Assignments

Assignment 1: Port Scanner Simulation

Accept a starting port and an ending port number. Use a for loop to print each port number in the range as “Scanning Port [n]…”.

Assignment 2: Disk Space Monitor

Write a while loop that takes user input for disk usage percentage. The loop should stop if input is 0. If usage > 90, print “Warning: High Disk Usage”. Print the total average of all inputs provided.

Assignment 3 � FizzBuzz (Classic Interview Question)

Print numbers from 1 to 50. - If a number is divisible by 3, print “Fizz”. - If divisible by 5, print “Buzz”. - If divisible by both 3 and 5, print “FizzBuzz”. - Otherwise, print the number itself.

Knowledge Assessment

Q1. Which function is most commonly used with a for loop to define a range of numbers- - A) loop() - B) range() - C) count() - D) list()

Q2. When does a while loop stop running- - A) After 10 iterations - B) When its condition becomes False - C) Only when break is used - D) When the program ends

Q3. What does the continue keyword do- - A) Stops the loop entirely - B) Skips to the next iteration - C) Restarts the loop from 1 - D) Checks if the condition is True

Q4. What is the output of range(2, 6)- - A) 2, 3, 4, 5, 6 - B) 2, 3, 4, 5 - C) 0, 1, 2, 3, 4, 5 - D) 2, 4, 6

Q5. How do you stop an infinite loop in the terminal- - A) Ctrl + Z - B) Alt + F4 - C) Ctrl + C - D) Press Enter

Technical Evaluation Preparation

Q1: “When should you choose a for loop over a while loop�

Ideal Answer: > “Use a for loop when the number of iterations is known in advance (e.g., iterating through a list of 10 items or a fixed range). Use a while loop when the number of iterations depends on a dynamic condition that changes during execution (e.g., waiting for specific user input or a server response).”

Q2: “What happens if you forget to update the loop variable in a while loop�

Ideal Answer: > “The condition will remain True forever, causing an ‘infinite loop’. This will consume CPU resources and make the program unresponsive until it is manually terminated.”

Q3: “Can a loop have an else block in Python�

Ideal Answer: > “Yes! A loop’s else block runs only if the loop completed naturally (i.e., it didn’t hit a break statement). This is very useful for searching for an item; if you find it and break, the else block won’t run, letting you know the search failed if it does run.”

Assignment Solution Key

1. Multiplication Table

num = int(input("Enter number: "))
for i in range(1, 11):
    print(f"{num} x {i} = {num * i}")

2. Sum of Evens

total = 0
while True:
    num = int(input("Enter number (0 to stop): "))
    if num == 0:
        break
    if num % 2 == 0:
        total += num
print(f"Sum of even numbers: {total}")

3. FizzBuzz

for i in range(1, 51):
    if i % 3 == 0 and i % 5 == 0:
        print("FizzBuzz")
    elif i % 3 == 0:
        print("Fizz")
    elif i % 5 == 0:
        print("Buzz")
    else:
        print(i)

Module 08: Comprehensions

Memory-Efficient Iteration and Declarative Data Transformation

Objectives

Module competency requires: - Assessment of Pythonic coding principles. - Implementation of List Comprehensions for optimized sequence generation. - Utilization of conditional comprehensions for data filtering and transformation. - Application of Dictionary and Set comprehensions for efficient mapping. - Analysis of performance trade-offs between comprehensions and iterative loops. - Development of a bulk system-data normalization utility.

Declarative Iteration

Comprehensions provide a concise, declarative syntax for generating new collections from existing iterables. This approach is optimized for performance and readability.

Performance Comparison

Iterative Approach (Standard Loop):

thresholds = [1, 2, 3, 4, 5]
adjusted = []
for t in thresholds:
    adjusted.append(t * 1.5)

Declarative Approach (List Comprehension):

adjusted = [t * 1.5 for t in thresholds]

Comprehensions are implemented at the C-level within the interpreter, offering execution speeds superior to standard append() operations in for loops.

List Comprehensions

The basic syntax follows this pattern: [expression for item in iterable]

# Double every number in a list
original = [10, 20, 30]
doubled = [x * 2 for x in original]  # [20, 40, 60]

# Create a list of uppercase names
names = ["rahul", "shiva", "amit"]
upper_names = [name.upper() for name in names] # ["RAHUL", "SHIVA", "AMIT"]

Conditional Comprehensions (Filtering and Logic)

You can add if statements inside a comprehension to filter the data.

1. Filtering (Only if)

[expression for item in iterable if condition]

nums = [1, 2, 3, 4, 5, 6, 7, 8]
evens = [x for x in nums if x % 2 == 0] # [2, 4, 6, 8]

2. Transforming (With if-else)

[val_if_true if condition else val_if_false for item in iterable]

nums = [10, 5, 20, 3]
status = ["Pass" if x >= 10 else "Fail" for x in nums]
# Result: ["Pass", "Fail", "Pass", "Fail"]

Dictionary and Set Comprehensions

The same logic applies to other data structures.

Dictionary Comprehension

{key_expr: val_expr for item in iterable}

names = ["Vijaylaxmi", "Rahul"]
name_lengths = {name: len(name) for name in names}
# Result: {'Vijaylaxmi': 5, 'Rahul': 3}

Set Comprehension

{expression for item in iterable} (Result is a unique set {})

nums = [1, 2, 2, 3, 3, 3, 4]
unique_squares = {x * x for x in nums} # {1, 4, 9, 16}

Technical Project: System Data Sanitizer

Develop a script to normalize a list of raw system identifiers and filter out non-human service accounts.

# ============================================
# PROJECT: System Data Sanitizer
# ============================================

raw_identifiers = ["  srv_node_01  ", "SYS_ADMIN", " guest_account ", "rahul_n ", " daemon_bot"]

# 1. Normalization: Whitespace removal and case standardization
clean_identifiers = [id.strip().lower() for id in raw_identifiers]

# 2. Gated Filtering: Exclude service bots
human_accounts = [id for id in clean_identifiers if "bot" not in id]

# 3. Conditional Labeling: Standardize account prefixes
final_inventory = [f"PRV_{a}" if len(a) > 10 else f"STD_{a}" for a in human_accounts]

print(f"Inventory Summary: {final_inventory}")

Assignments

Assignment 1: Disk Threshold Adjuster

Given a list of disk usage percentages: [15, 88, 42, 95, 20]. - Use a list comprehension to return a list where percentages > 80 are flagged with the string “CRITICAL”, and others remain as integers.

Assignment 2: Hostname Encoding Map

Take a string: server-node-01. - Generate a dictionary where each character is a key and its corresponding ASCII value is the value.

Assignment 3 � Multiples of 3 and 5

Use a single list comprehension to find all numbers between 1 and 100 that are divisible by both 3 and 5.

Knowledge Assessment

Q1. What is the main advantage of using comprehensions- - A) They are required for math - B) They are concise and faster (Pythonic) - C) They can replace all loops - D) They work without lists

Q2. Which brackets are used for a List Comprehension- - A) {} - B) () - C) [] - D) <>

Q3. Where does the if keyword go if you only want to FILTER items- - A) Before the for - B) At the very end - C) Inside the for - D) It’s not allowed

Q4. What is the result of {x for x in [1,1,2,2]}- - A) [1, 1, 2, 2] - B) {1, 2} - C) (1, 2) - D) Error

Q5. When should you AVOID using a comprehension- - A) For small lists - B) When doing math - C) When the logic is too complex to read in one line - D) Never, always use them

Technical Evaluation Preparation

Q1: “Are comprehensions faster than traditional loops�

Ideal Answer: > “Yes, in most cases. List comprehensions are implemented in optimized C code within the Python interpreter, making them faster than manually appending items to a list in a for loop. However, the performance difference is usually only noticeable with very large datasets.”

Q2: “What is the difference between an if at the end and an if-else at the start�

Ideal Answer: > “An if at the end (after the for) is a filter; it determines IF the item gets added at all. An if-else at the start (before the for) is a transformation; it determines WHAT value is added for every single item.”

Q3: “What is a Generator Expression, and how does it differ from a list comprehension�

Ideal Answer: > “A Generator Expression uses parentheses () instead of square brackets []. While a list comprehension creates the entire list in memory immediately, a generator produces items one-by-side only when requested (lazy evaluation). This makes generators much more memory-efficient for extremely large datasets.”

Assignment Solution Key

1. Price Discounter

prices = [100, 250, 45, 800, 120]
discounted = [p * 0.9 if p > 200 else p for p in prices]
print(discounted)

2. Character Counter

text = "Python"
codes = {char: ord(char) for char in text}
print(codes)

3. Multiples of 3 and 5

multiples = [x for x in range(1, 101) if x % 3 == 0 and x % 5 == 0]
print(multiples)

Module 09: Lists

Sequence Management, Array Operations, and Mutable Buffers

Objectives

Module competency requires: - Management of List objects and dynamic containers. - Analysis of mutability and object identity. - Utilization of list methods: append(), pop(), and sort(). - Implementation of advanced slicing and sequence operations. - Management of multi-dimensional (nested) list structures. - Development of a Service Registry Manager utility.

List Overview

A List is an ordered, mutable collection of objects. Unlike primitive types, lists can encapsulate heterogeneous data types.

Operational Characteristics:

1. Ordered Persistence: Positional integrity is maintained.
2. In-Place Mutability: Direct modification of the object buffer is permitted.
3. Dynamic Scaling: The interpreter handles memory reallocation during expansion.

fruits = ["Apple", "Banana", "Cherry"]
mixed = [1, "Hello", 3.14, True]
empty = []

Indexing and Mutability Operations

Indexing works exactly like strings, but since lists are mutable, you can use the index to change a value.

shopping = ["Milk", "Bread", "Eggs"]

# 1. Accessing
print(shopping[0])  # Output: Milk

# 2. Changing (Mutability)
shopping[1] = "Butter" 
print(shopping)     # Result: ["Milk", "Butter", "Eggs"]

# 3. Slicing
print(shopping[1:]) # Result: ["Butter", "Eggs"]

List Manipulation Methods

Python provides powerful methods to modify lists.

# Task: Create a guest list
guests = ["Rahul", "Amit"]
guests.append("Sonal")     # ["Rahul", "Amit", "Sonal"]
guests.insert(1, "Sneha")  # ["Rahul", "Sneha", "Amit", "Sonal"]
guests.sort()              # Alphabetical order
print(guests)

List Arithmetic and Membership Operations

You can use operators to combine or check for items in a list.

• len(L) : Returns the number of items.
• in / not in : Checks if an item exists.
• + : Joins two lists.
• * : Repeats a list.

nums = [1, 2, 3]
more_nums = [4, 5]

all_nums = nums + more_nums # [1, 2, 3, 4, 5]
print(10 in all_nums)       # False
print(len(all_nums))        # 5

Nested Lists (Multi-Dimensional Data Structures)

A list can contain other lists. This is how we represent grids, tables, or matrices.

# A 3x3 Grid (Tic-Tac-Toe style)
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Accessing Row 1, Column 2 (Index 1, 2)
print(matrix[1][2]) # Access point for specific coordinate data

Technical Project: Service Registry Manager

Develop a Command-Line utility for managing a registry of active system services.

# ============================================
# PROJECT: Service Registry Manager
# ============================================

active_services = []

print("--- System Service Registry Manager ---")

while True:
    print("\n[1] List Services | [2] Register Service | [3] Decommission Service | [4] Exit")
    choice = input("Enter operational command: ")

    if choice == "1":
        print("\n--- ACTIVE REGISTRY ---")
        if not active_services:
            print("(Registry empty)")
        else:
            for i, service in enumerate(active_services, 1):
                print(f"ID-{i:02}: {service}")
    
    elif choice == "2":
        new_service = input("Enter service identifier: ").strip().upper()
        active_services.append(new_service)
        print("Service successfully registered.")
    
    elif choice == "3":
        if not active_services:
            print("Error: No services available for decommission.")
            continue
        try:
            idx = int(input("Enter registry ID for decommissioning: ")) - 1
            if 0 <= idx < len(active_services):
                removed = active_services.pop(idx)
                print(f"Decommissioned: {removed}")
            else:
                print("Error: Invalid registry identifier.")
        except ValueError:
            print("Error: Identifier must be numeric.")
            
    elif choice == "4":
        print("Terminating Management Session.")
        break
    else:
        print("Error: Unrecognized command.")

Assignments

Assignment 1: Dynamic IP Inventory

Accept 5 IP addresses via user input. - Store them in a list and sort them numerically/alphabetically. - Output the resulting inventory list.

Assignment 2: Memory Limit Filter

Given a list of process memory footprints in MB: [120, 450, 80, 200, 600, 150]. - Accept a threshold value from the user. - Generate a new list containing only processes that exceed the threshold.

Assignment 3 � Matrix Transpose (Challenge)

Take a 2x2 matrix: [[1, 2], [3, 4]]. - Write code to swap the rows and columns. - Result should be: [[1, 3], [2, 4]].

Knowledge Assessment

Q1. What is the output of L = [1, 2]; L.append([3, 4]); print(len(L))- - A) 4 - B) 3 (The list [3,4] is treated as one item) - C) 2 - D) Error

Q2. Which method removes an item by its VALUE, not its index- - A) pop() - B) remove() - C) clear() - D) delete()

Q3. How do you find the index of the value “Apple” in a list fruits- - A) fruits.find("Apple") - B) fruits.index("Apple") - C) fruits.search("Apple") - D) fruits["Apple"]

Q4. True or False: You can change a specific character in a String like you can in a List. - A) True - B) False (Strings are immutable, Lists are mutable)

Q5. What does L[-1] return- - A) The first item - B) The last item - C) An error - D) A reversed list

Technical Evaluation Preparation

Q1: “What is the difference between extend() and append()�

Ideal Answer: > “append() adds its argument as a single element to the end of a list. extend() iterates over its argument and adds each item to the list. For example, L.append([1,2]) results in [..., [1,2]], but L.extend([1,2]) results in [..., 1, 2].”

Q2: “How does Python handle list memory internally�

Ideal Answer: > “Python lists are overallocated, meaning they allocate more space than needed to accommodate future growth. When you append, it’s usually an O(1) operation. When the capacity is full, Python ‘resizes’ the list by creating a larger array and copying the elements, which happens occasionally.”

Q3: “What is a ‘Shallow Copy’ vs a ‘Deep Copy’ in lists�

Ideal Answer: > “A shallow copy (using L.copy()) creates a new list, but if the list contains objects (like other lists), both the old and new list will point to the same internal objects. A deep copy (using the copy module) recursively copies everything, ensuring the new list is completely independent of the original.”

Assignment Solution Key

1. Unique Guest List

guests = []
for i in range(5):
    guests.append(input(f"Enter name {i+1}: "))
guests.sort()
print(f"First: {guests[0]}, Last: {guests[-1]}")

2. Shopping Budget

prices = [25.5, 99.0, 10.0, 45.0, 150.0]
budget = float(input("Budget: "))
affordable = [p for p in prices if p <= budget]
print(f"Affordable: {affordable}, Total: {sum(affordable)}")

3. Matrix Transpose

m = [[1, 2], [3, 4]]
transposed = [[m[0][0], m[1][0]], [m[0][1], m[1][1]]]
print(transposed)

Module 10: Tuples

Immutable Sequences and Fixed-Size Buffers

Objectives

Module competency requires: - Assessment of immutability in stable data structures. - Implementation of Tuples for fixed sequence management. - Utilization of Packing and Unpacking for efficient data assignment. - Analysis of performance metrics: Tuples vs Lists. - Development of a Database Connection Registry.

Immutability and Data Integrity

A Tuple is an ordered, immutable collection. Unlike Lists, the contents of a tuple cannot be modified post-initialization.

Operational examples include storing database credentials, network port ranges, or localized system constants.

# List (Changeable)
my_list = [1, 2, 3]
my_list[0] = 100 # Totally fine

# Tuple (Unchangeable)
my_tuple = (1, 2, 3)
# my_tuple[0] = 100 #  Error: 'tuple' object does not support item assignment

Tuple Initialization and Access

Tuples use round brackets () instead of square brackets [].

- The Single-Item Trap

To create a tuple with only one item, you MUST include a trailing comma. Otherwise, Python thinks it’s just a regular parenthesis used in math.

not_a_tuple = ("Rahul")  # Result: String
is_a_tuple = ("Rahul",)   # Result: Tuple

Accessing Data

Accessing is identical to Lists and Strings:

colors = ("Red", "Green", "Blue")
print(colors[0])    # Output: Red
print(colors[-1])   # Output: Blue

Tuple Packing and Unpacking Logic

This is one of Python’s most elegant features.

1. Packing (Grouping)

# Creating a tuple without even using parentheses
point = 10, 20
print(type(point)) # <class 'tuple'>

2. Unpacking (Shortcut Assignments)

user_info = ("Rahul", 28, "India")

# Instead of doing it 3 times:
# name = user_info[0] ...
name, age, country = user_info 

print(name)    # Rahul
print(country) # India

Comparative Analysis: Tuples vs Lists

Immutable Sequence Methods

Since you can’t change a tuple, you only have two methods: 1. .count(value) : Returns how many times a value appears. 2. .index(value) : Returns the first position of a value.

nums = (1, 2, 2, 3)
print(nums.count(2)) # Output: 2
print(nums.index(3)) # Output: 3

Technical Project: Database Connection Registry

Develop a registry of static database connection parameters. Since these parameters are fixed for the environment, tuples ensure they cannot be modified by downstream processes.

# ============================================
# PROJECT: Database Connection Registry
# ============================================

# Records stored as tuples: (DB_Identifier, (Host, Port, SSL_Enabled))
db_registry = [
    ("PROD_DB", ("10.0.0.50", 5432, True)),
    ("STAGING_DB", ("10.0.0.61", 5432, False)),
    ("LEGACY_DATA", ("192.168.1.15", 3306, True))
]

print("--- Data Infrastructure Registry ---")

for db_id, config in db_registry:
    host, port, ssl = config  # Unpacking nested configuration
    ssl_status = "ENABLED" if ssl else "DISABLED"
    
    print(f"Registry ID: {db_id}")
    print(f"   Endpoint : {host}:{port}")
    print(f"   Encryption: {ssl_status}")
    print("-" * 30)

# Implementation Note:
# db_registry[0][1][0] = "localhost" # This raises a TypeError, preventing accidental config drift.

Assignments

Assignment 1: System Service Record

Initialize a tuple called service_record containing a service_name, uptime_seconds, and status_code. - Attempt to increment uptime_seconds directly and observe the exception. - Unpack the record and format an status message: “Service [Name] reported status [Code] after [Seconds]s uptime.”

Assignment 2: Variable Swap Implementation

Implement the Pythonic variable swap for two server identifiers: primary = "SRV-01" and secondary = "SRV-B". - Execute the swap in a single statement using tuple unpacking. - Verify the identifiers after the swap.

Assignment 3 � Subject Marks

Create a tuple containing marks for 5 subjects. - Print the highest and lowest marks using max() and min(). - Print how many times the score 100 appears in the list.

Knowledge Assessment

Q1. What happens if you try to append() to a tuple- - A) It adds the item to the end - B) It creates a new list - C) It raises a AttributeError (Tuples don’t have append) - D) It works if the tuple is empty

Q2. Which of the following is a valid tuple- - A) t = [1, 2] - B) t = (1) - C) t = (1,) - D) t = {1, 2}

Q3. What is “Unpacking” in Python- - A) Removing items from a tuple - B) Assigning tuple items to multiple variables at once - C) Merging two tuples - D) Converting a tuple to a list

Q4. Why are tuples faster than lists- - A) Because they use different brackets - B) Because their fixed size allows memory optimization - C) Because they can’t store strings - D) They are not faster

Q5. What is the output of t = (1, 2, 3); print(t * 2)- - A) (2, 4, 6) - B) (1, 2, 3, 1, 2, 3) - C) Error - D) (1, 2, 3, 2, 4, 6)

Technical Evaluation Preparation

Q1: “If tuples are immutable, can they contain a mutable object like a list�

Ideal Answer: > “Yes. A tuple can contain a list. While the tuple’s references are fixed (you can’t swap the list for another object), the contents of the list inside the tuple can still be changed. This is an important distinction between ‘shallow’ and ‘deep’ immutability.”

Q2: “When should I use a Tuple instead of a List�

Ideal Answer: > “Use a Tuple when you have a sequence of data that acts as a single ‘record’ (like an address or coordinate) or when you want to ensure the data cannot be accidentally changed by another part of the program. It provides a signal to other developers that this data is constant.”

Q3: “What is namedtuple and why is it useful�

Ideal Answer: > “namedtuple is a factory function from the collections module. It creates tuple-like objects that have fields accessible by attribute lookup (like point.x) as well as being indexable. It makes code much more readable while maintaining the performance and immutability of a tuple.”

Assignment Solution Key

1. Personal ID Card

identity = ("Rahul", 28, "Engineer")
# identity[1] = 29 #  Raises TypeError
name, age, prof = identity
print(f"Hello, I am {name}, a {prof} and I am {age} years old.")

2. Swapping Variables

a = 5
b = 10
a, b = b, a # The Python Trick!
print(f"a: {a}, b: {b}")

3. Subject Marks

marks = (85, 100, 92, 100, 78)
print(f"Max: {max(marks)}, Min: {min(marks)}")
print(f"Distinctions: {marks.count(100)}")

Module 11: Dictionaries

Key-Value Pairings, Hash Maps, and Fast Data Retrieval

Objectives

Module competency requires: - Analysis of associative arrays and Key-Value pairings. - Implementation of Dictionary objects using curly-brace {} initialization. - Utilization of dictionary methods: .get(), .keys(), and .items(). - Management of dynamic data insertion, updates, and deletion. - Management of nested dictionary structures for complex telemetry data. - Development of a Service Configuration Registry utility.

Dictionary Logic

A Dictionary is an unordered (post-3.7, insertion-ordered), mutable collection of items stored as Key-Value pairs.

Structural Constraints:

1. Key Uniqueness: Duplicate keys are not permitted; subsequent assignments overwrite previous values.
2. Key Immutability: Keys must be hashable objects (Strings, Integers, or Tuples).
3. Value Flexibility: Values can encapsulate any data type, including complex nested structures.

# A simple dictionary
user = {
    "name": "Rahul",
    "age": 28,
    "city": "Mumbai"
}

Dictionary Initialization and Accessing

Dictionaries use curly braces {} and colons : to separate keys and values.

1. Accessing via Key

profile = {"username": "coder_pro", "id": 99}
print(profile["username"]) # Output: coder_pro

Gated Access: The .get() Method

Direct access via square brackets [] raises a KeyError if the specified key is absent. The .get() method provides a non-disruptive alternative, returning None or a specified default value if the key is not found.

# print(profile["email"])   # Crash! KeyError
print(profile.get("email")) # Result: None
print(profile.get("email", "Not Found")) # Result: "Not Found" (Custom default)

Dictionary Views and Iteration Methods

To work with dictionaries, you need to know how to extract their parts.

car = {"brand": "Tesla", "model": "Model S", "year": 2023}

print(car.keys())   # dict_keys(['brand', 'model', 'year'])
print(car.values()) # dict_values(['Tesla', 'Model S', 2023])

# Perfect for loops:
for key, value in car.items():
    print(f"{key}: {value}")

Mutable Operations: Adding, Updating, and Removal

Dictionaries are mutable, so you can change them on the fly.

1. Adding/Updating

user = {"name": "Amit"}
user["age"] = 25       # ADDING a new key
user["name"] = "Rahul" # UPDATING an existing key

2. Removing

# Using pop (returns the value)
age = user.pop("age") 

# Using del
del user["name"]

Nested Dictionary Structures

In the real world, data is complex. We often nest dictionaries inside dictionaries.

employees = {
    101: {"name": "Vijaylaxmi", "role": "Dev", "skills": ["Python", "JS"]},
    102: {"name": "Rahul", "role": "Designer", "skills": ["Figma", "CSS"]}
}

# Accessing Rahul's first skill
print(employees[102]["skills"][0]) # Output: Figma

Technical Project: Service Configuration Registry

Develop a Command-Line utility for managing a registry of active system service configurations.

# ============================================
# PROJECT: Service Configuration Registry
# ============================================

service_registry = {
    "WEB_PROD": {"host": "10.0.0.10", "port": 443, "status": "UP"},
    "DB_PROD": {"host": "10.0.0.50", "port": 5432, "status": "UP"}
}

print("--- System Service Configuration Management ---")

while True:
    print("\n[1] Query Service | [2] Update Config | [3] Remove Service | [4] List All | [5] Exit")
    choice = input("Select Operational Command: ")

    if choice == "1":
        id = input("Enter Service identifier: ").upper()
        config = service_registry.get(id, "Record missing.")
        print(f"Operational Config for {id}: {config}")

    elif choice == "2":
        id = input("Enter Service ID: ").upper()
        host = input("Target Host: ")
        port = int(input("Target Port: "))
        service_registry[id] = {"host": host, "port": port, "status": "RESTARTING"}
        print("Service configuration updated.")

    elif choice == "3":
        id = input("Enter Service ID to decommission: ").upper()
        if id in service_registry:
            service_registry.pop(id)
            print(f"Service {id} decommissioned successfully.")
        else:
            print("Error: Identifier not found.")

    elif choice == "4":
        print("\n--- ACTIVE REGISTRY ---")
        for s_id, cfg in service_registry.items():
            print(f"SERVICE: {s_id} -> {cfg}")

    elif choice == "5":
        print("Terminating Management Session.")
        break
    else:
        print("Error: Invalid Choice.")

Assignments

Assignment 1: Log Event Frequency Counter

Accept a string representing a sequence of log events: "INFO ERROR INFO INFO WARNING ERROR". - Split the string and utilize a dictionary to count the frequency of each event type.

Assignment 2: Infrastructure Health Registry

Create a dictionary with server cluster names as keys and a list of their current uptime percentages (0-100) as values. - Calculate and output the average uptime for each cluster.

Assignment 3 � Nested Profile

Create a dictionary representing your “Home Library”. - Keys: Book Titles. - Values: Another dictionary with author and year. - Print only the authors of books published after the year 2010.

Knowledge Assessment

Q1. Which symbol is used to create a dictionary- - A) [] - B) () - C) {} - D) <>

Q2. What error is raised if you access a non-existent key using square brackets []- - A) ValueError - B) KeyError - C) NameError - D) TypeError

Q3. Which method allows you to access a key safely without crashing- - A) find() - B) search() - C) get() - D) safe()

Q4. What does the .items() method return- - A) A list of values - B) A list of keys - C) A collection of Key-Value tuples - D) The length of the dictionary

Q5. True or False: Dictionary keys must be unique. - A) True - B) False

Technical Evaluation Preparation

Q1: “Are Python dictionaries ordered�

Ideal Answer: > “As of Python 3.7+, dictionaries maintain the insertion order. This means when you iterate through a dictionary, the items will appear in the same order they were added. However, you should still use a dictionary primarily for ‘lookup by key’ rather than ‘lookup by position’.”

Q2: “What is the time complexity of a dictionary lookup�

Ideal Answer: > “Dictionary lookups are extremely fast, with an average time complexity of O(1) (constant time). This is because Python uses a Hash Table internally, which allows it to jump directly to the memory location of a key instead of searching line-by-line like a list.”

Q3: “What can be used as a dictionary Key�

Ideal Answer: > “Only hashable (immutable) objects can be used as keys. This includes strings, integers, floats, and tuples. Lists and other dictionaries cannot be keys because they are mutable and their hash value could change, making it impossible for Python to find them later.”

Assignment Solution Key

1. Word Frequency Counter

text = input("Enter sentence: ").lower()
words = text.split()
counts = {}
for w in words:
    counts[w] = counts.get(w, 0) + 1
print(counts)

2. Student Grades

grades = {
    "Rahul": [80, 90, 85],
    "Amrita": [95, 88, 92],
    "Shiva": [70, 75, 80]
}
for name, marks in grades.items():
    avg = sum(marks) / len(marks)
    print(f"{name}'s Average: {round(avg, 2)}")

3. Nested Profile

library = {
    "Python 101": {"author": "Rahul", "year": 2026},
    "Old Tales": {"author": "Classic", "year": 1990},
    "Modern JS": {"author": "Dev", "year": 2021}
}
for title, info in library.items():
    if info["year"] > 2010:
        print(f"Title: {title}, Author: {info['author']}")

Module 12: Sets

Unique Sequence Evaluation and Set Mathematics

Objectives

Module competency requires: - Management of Set objects for unique, unordered data collections. - Comparison of performance and structural differences between Lists and Sets. - Implementation of Set Mathematics: Union, Intersection, and Difference. - Utilization of Frozen Sets for immutable unique collections. - Development of an automated log entry deduplicator.

Set Properties

A Set is an unordered collection of unique elements. Python’s set implementation utilizes a hash table to ensure that every item within the collection is distinct.

Operational Characteristics:

1. Unordered Storage: Items do not maintain a fixed position; indexing is not supported.
2. Mandatory Uniqueness: Duplicate values are automatically discarded.
3. Mutable Container: Elements can be added or removed, though the elements themselves must be hashable (immutable).

Key Features: 1. Unordered: Items have no fixed position (no indexing). 2. Unique: No duplicate values allowed. 3. Mutable: You can add/remove items (but items inside must be immutable).

# A simple set
my_set = {1, 2, 3, 3, 3}
print(my_set) # Output: {1, 2, 3} (Duplicates are gone!)

Set Initialization and Uniqueness Operations

Sets use curly braces {} just like dictionaries, but without the colons :.

- The Empty Set Trap

If you use empty = {}, Python creates an empty Dictionary. To create an empty Set, you must use the set() function.

is_dict = {} 
is_set = set() # Standard initialization

Removing Duplicates from a List

This is the #1 real-world use for sets:

emails = ["a@x.com", "b@x.com", "a@x.com"]
unique_emails = list(set(emails)) # List -> Set -> List
print(unique_emails) # ["b@x.com", "a@x.com"]

Mathematical Set Operations (Algebraic Logic)

Python sets allow you to perform powerful “Venn Diagram” operations using symbols.

A = {1, 2, 3}
B = {3, 4, 5}

print(A | B) # {1, 2, 3, 4, 5}
print(A & B) # {3}
print(A - B) # {1, 2}

Modification and Membership Evaluation

Since sets have no index, you use specific methods to change them.

• .add(item) : Adds one item.
• .update([list]) : Adds multiple items.
• .remove(item) : Removes item (Errors if not found).
• .discard(item) : Removes item (Safe; no error if not found).

Membership Checking (Efficiency): Checking if an item exists in a set (x in my_set) is significantly faster than checking a list, especially as the data grows to thousands of items.

Frozen Sets: Immutable Unique Containers

A frozenset is an immutable version of a set. Once created, you cannot add or remove items. This allows you to use a set as a Key in a Dictionary.

fs = frozenset([1, 2, 3])
# fs.add(4) #  Error

Technical Project: Automated Log Deduplicator

Develop a script to process multiple system logs and extract unique service identifiers while identifying common active processes across different timeframes.

# ============================================
# PROJECT: Automated Log Deduplicator
# ============================================

log_batch_01 = {"SRV_WEB", "SRV_DB", "SRV_AUTH", "SRV_CACHE", "SRV_WEB"}
log_batch_02 = {"SRV_PROXY", "SRV_DB", "SRV_WEB", "SRV_LB"}

print(f"Log Sequence A: {log_batch_01}")
print(f"Log Sequence B: {log_batch_02}")

# 1. Intersection: Which services were active in BOTH batches-
persistent_services = log_batch_01 & log_batch_02
print(f"\nPersistent active services: {persistent_services}")

# 2. Union: Total unique services across all logs-
inventory_summary = log_batch_01 | log_batch_02
print(f"Consolidated Service Inventory: {len(inventory_summary)} unique entries")

# 3. Difference: Which services were introduced in the second batch-
new_service_activity = log_batch_02 - log_batch_01
print(f"New services detected in Batch B: {new_service_activity}")

Assignments

Assignment 1: Infrastructure Skill Mapping

Take two sets of infrastructure skills: PrimaryStack = {"Python", "AWS", "Terraform"} and SecondaryStack = {"AWS", "Ansible", "Docker"}. - Extract the union of all skills. - Extract the intersection (common skills). - Extract skills unique to the PrimaryStack.

Assignment 2: Hostname Deduplicator

Accept a space-separated string of hostnames from the user. - Utilize a set to extract and print all unique hostnames. - Output the total count of distinct hosts.

Assignment 3 � Set Comparison

Create a set of numbers from 1 to 10. - Create another set of even numbers from 1 to 15. - Print the Symmetric Difference (Numbers that are in one set or the other, but not both).

Knowledge Assessment

Q1. What is the result of {1, 2} | {2, 3}- - A) {1, 2, 2, 3} - B) {1, 2, 3} - C) {2} - D) {1, 3}

Q2. How do you create an EMPTY set- - A) s = {} - B) s = set() - C) s = [] - D) s = set({})

Q3. Which operation finds items present in BOTH sets- - A) Union (|) - B) Intersection (&) - C) Difference (-) - D) Invert (~)

Q4. True or False: You can access a set item using my_set[0]. - A) True - B) False (Sets are unordered and do not support indexing)

Q5. Which method is safer for removing an item- - A) remove() - B) pop() - C) discard() - D) delete()

Technical Evaluation Preparation

Q1: “Why is searching in a Set faster than in a List�

Ideal Answer: > “Sets are implemented using a Hash Table. When you check x in s, Python hashes the value and jumps directly to its bucket in memory. In a List, Python must scan every item from start to finish (O(n) complexity), while in a Set, it’s a constant time operation (O(1)).”

Q2: “Can a Set contain a List as an element�

Ideal Answer: > “No. Sets can only contain hashable (immutable) objects. Since Lists are mutable and can change, their hash value is not constant, so they cannot be stored in a set. You would need to convert the list to a Tuple first.”

Q3: “Practical use-case: How would you find common elements between three different lists�

Ideal Answer: > “Convert the first list to a set and then use the .intersection() method, passing the other two lists as arguments: set(list1).intersection(list2, list3). This is much cleaner and faster than using multiple nested loops.”

Assignment Solution Key

1. Skill Parser

Vijaylaxmi = {"Python", "Java", "SQL"}
Rahul = {"Java", "C++", "JS"}
print(f"All: {Vijaylaxmi | Rahul}")
print(f"Common: {Vijaylaxmi & Rahul}")
print(f"Only Vijaylaxmi: {Vijaylaxmi - Rahul}")

2. String Deduplicator

text = input("Enter text: ").replace(" ", "")
unique_chars = set(text)
print(f"Unique: {unique_chars}, Count: {len(unique_chars)}")

3. Set Comparison

s1 = set(range(1, 11))
s2 = set(range(2, 16, 2))
print(f"Symmetric Diff: {s1 ^ s2}")

Module 13: Functions (Part 1)

Procedural Abstraction, Variable Scope, and Reusable Logic Blocks

Objectives

Module competency requires: - Application of the DRY (Don’t Repeat Yourself) principle for code optimization. - Definition and invocation of custom Functions using the def keyword. - Management of data flow via Parameters and Arguments. - Implementation of the return statement for procedural output. - Utilization of Docstrings for standardized code documentation. - Development of a multi-parameter system resource calculator.

Procedural Abstraction: The DRY Principle

DRY (Don’t Repeat Yourself) is a core software engineering principle focused on reducing redundancy.

Advantages of Functional Encapsulation:

1. Maintainability: Centralized logic allows for global updates via single-point modifications.
2. Modular Organization: Complex workflows are decomposed into discrete, testable units.
3. Execution Efficiency: Reduces code bloat and minimizes potential for copy-paste errors.

Functions act as logical black boxes that ingest inputs (parameters), process them, and yield outputs (returns) without requiring the caller to rebuild the underlying logic for every execution.

Function Definition and Invocation

We use the def keyword to define a function.

# 1. DEFINING a function
def say_hello():
    """Prints a simple greeting."""
    print("System initialization routine complete.")

# 2. CALLING a function
say_hello() 
say_hello() # Can be called multiple times

Naming Rules: - Use snake_case (lowercase with underscores). - Use verbs as names (e.g., calculate_tax, show_results).

Parameters and Positional Arguments

To make a function useful, we often need to send data into it.

• Parameter: The variable listed in the function definition (The “Placeholder”).
• Argument: The actual value sent to the function when calling it (The “Input”).

def greet_user(name): # 'name' is the Parameter
    print(f"Hello, {name}!")

greet_user("Rahul")  # "Rahul" is the Argument
greet_user("Amit")   # "Amit" is the Argument

Data Returns: The return Statement

Most functions don’t just “print” things; they calculate a value and send it back so it can be used elsewhere in the program.

def add(a, b):
    result = a + b
    return result # Sends the value back

# Storing the returned value in a variable
total = add(10, 5) 
print(f"The sum is: {total}")

# print() vs return
# print() just shows text on the screen.
# return gives the data back to the person who called the function.

Documentation Standards: Docstrings

Professional developers always document what their functions do using Docstrings. These are triple-quoted strings placed immediately inside the function.

def get_area(radius):
    """
    Calculates the area of a circle.
    Input: radius (float)
    Output: area (float)
    """
    return 3.14 * (radius ** 2)

# You can access this documentation using help()
# help(get_area)

Technical Project: Infrastructure Cost and Resource Calculator

Develop a utility to calculate total operational costs for cloud instances based on hourly rates, uptime, and applicable enterprise discounts.

# ============================================
# PROJECT: Cloud Resource Cost Calculator
# ============================================

def calculate_infrastructure_cost(hourly_rate, uptime_hours, discount_multiplier=1.0):
    """
    Computes total operational expenditure after applying discounts.
    """
    base_cost = hourly_rate * uptime_hours
    final_cost = base_cost * discount_multiplier
    
    return round(final_cost, 2)

# --- Operational Logic ---
instance_rate = float(input("Enter Hourly Rate ($): "))
hours_run = float(input("Enter Uptime (Hours): "))
ent_discount = float(input("Enter Discount Multiplier (e.g., 0.9 for 10% off): "))

total_expenditure = calculate_infrastructure_cost(instance_rate, hours_run, ent_discount)

print("\n--- OPERATIONAL EXPENDITURE REPORT ---")
print(f"Base Hourly Rate: ${instance_rate}")
print(f"Total Uptime    : {hours_run} hours")
print(f"FINAL COST      : ${total_expenditure}")

***

## Assignments

### Assignment 1: Disk Capacity Calculator
Create a function `get_available_storage(total_cap, used_cap)`.
- The function must return the remaining capacity.
- Accept inputs from the user and output the result.

### Assignment 2: Security Credential Validator
Create a function `is_valid_token(token)`.
- Return `True` if the token length is exactly 16 characters, otherwise `False`.
- Test with multiple inputs.

### Assignment 3 — Temperature Converter
Write a function that converts Celsius to Fahrenheit.
- Formula: `F = (C * 9/5) + 32`
- Create another function that converts Fahrenheit to Celsius.

***

## Knowledge Assessment

**Q1. Which keyword is used to create a function in Python-**
- A) `function`
- B) `create`
- C)  `def`
- D) `method`

**Q2. What is the difference between an Argument and a Parameter-**
- A) Parameters are the values, Arguments are the variables.
- B)  Parameters are the variables in the definition, Arguments are the actual values passed.
- C) There is no difference.
- D) Arguments are only for numbers.

**Q3. What happens if a function has no `return` statement-**
- A) It crashes.
- B) It returns 0.
- C)  It returns `None` automatically.
- D) It loops forever.

**Q4. Where should a Docstring be placed-**
- A) Above the `def` line.
- B)  On the first line inside the function body.
- C) At the end of the file.
- D) Anywhere inside the function.

**Q5. Can a function call another function-**
- A)  Yes, this is common practice.
- B) No, functions must be independent.
- C) Only if they share the same name.

***

## Technical Evaluation Preparation

### Q1: "What is the 'Scope' of a variable inside a function—
 **Ideal Answer:**
> "Variables created inside a function are called **Local Variables**. They only exist while the function is running. Once the function finishes, these variables are destroyed and cannot be accessed from outside. This is known as **Local Scope**."

### Q2: "What is the difference between `print()` and `return` inside a function—
 **Ideal Answer:**
> "`print()` is an output for the **user** to see on the console; it doesn't allow the program to use that data later. `return` is an output for the **program**; it sends a value back to the caller so it can be stored in a variable or used in further calculations."

### Q3: "What are 'Default Arguments' and why are they used—
 **Ideal Answer:**
> "Default arguments allow you to assign a value to a parameter in the definition (e.g., `def greet(msg="Hello")`). If the caller doesn't provide an argument, the default is used. This makes functions more flexible and easier to use when certain values are the same 90% of the time."

***

##  Assignment Solution Key

### 1. Area Calculator
```python
def calculate_rectangle_area(l, w):
    return l * w

length = float(input("Length: "))
width = float(input("Width: "))
print(f"Area: {calculate_rectangle_area(length, width)}")

2. Password Security

def is_strong_password(p):
    return len(p) >= 8

print(is_strong_password("123"))      # False
print(is_strong_password("password")) # True

3. Temperature Converter

def c_to_f(c):
    return (c * 9/5) + 32

def f_to_c(f):
    return (f - 32) * 5/9

print(f"0C is {c_to_f(0)}F")
print(f"100F is {round(f_to_c(100), 2)}C")

Module 14.5: Logic Consolidation Project

Architecting Custom Automation Workflows

Module 14.5 of 37

Objectives

Module competency requires: - Integration of Lists, Dictionaries, and Sets within a single logical framework. - Implementation of higher-order functions and modularized logic blocks. - Development of a complex “Real-World” automation utility. - Preparation for Object-Oriented Programming (OOP) architectures.

The “Bridge” Challenge

Before transitioning to Object-Oriented Programming (OOP), it is critical to master the orchestration of independent data structures. In professional DevOps environments, data often arrives as a series of complex lists or dictionaries which must be filtered, transformed, and validated using custom functions.

The Problem: Multi-Component Health Audit

You have been tasked with building a System Health Dashboard script. The script must process raw telemetry data from multiple servers, filter out irrelevant status codes, and generate a unique list of unhealthy nodes.

Data Structure Consolidation Map

1. The Raw Telemetry (Dictionary)

Each entry in your telemetry source is a dictionary representing a server node.

2. The Filter Criteria (Set)

Use a Set to maintain a high-performance collection of “Known Critical” error codes.

3. The Result Set (List)

A list will store the final objects (Filtered Dictionaries) to be reported to the dashboard.

technical Project: Automated Node Audit Utility

Develop a script that integrates all concepts from Modules 01-14.

# ============================================
# PROJECT: Automated Node Audit Utility (Logic Consolidation)
# ============================================

# 1. Configuration (Set for fast lookups)
CRITICAL_ERRORS = {"E-101", "E-404", "E-500"}

# 2. Raw Telemetry Data (List of Dictionaries)
raw_telemetry = [
    {"node": "Web-01", "cpu": 45, "status": "E-101"},
    {"node": "DB-01",  "cpu": 88, "status": "OK"},
    {"node": "API-01", "cpu": 12, "status": "E-500"},
    {"node": "Cache-01", "cpu": 10, "status": "E-202"},
]

def audit_node(node_data):
    """
    Evaluates a single node's data.
    Returns True if the node is in CRITICAL failure state.
    """
    status = node_data.get("status")
    cpu_load = node_data.get("cpu", 0)
    
    # Logic: Higher than 80% CPU OR has a critical error code
    if status in CRITICAL_ERRORS or cpu_load > 80:
        return True
    return False

def generate_report(telemetry):
    """
    Orchestrates the audit across all nodes.
    """
    unhealthy_nodes = [node["node"] for node in telemetry if audit_node(node)]
    return unhealthy_nodes

# Main Execution
failed_nodes = generate_report(raw_telemetry)

print("--- SYSTEM HEALTH REPORT ---")
print(f"Nodes found requiring intervention: {failed_nodes}")

Operational Insight

“In the real world, you don’t just write scripts; you architect workflows. This project forces you to think about how data flows from a raw ‘telemetry’ list into a filtered ‘critical’ set and finally into an ‘actionable’ report. Mastering this functional orchestration is the final step before we move into the structural power of Classes and Objects.”

Next: Module 15 � Classes & Objects

Module 14: Functions (Part 2)

Variable Scope Resolution, Global State Management, and Functional Mapping

Objectives

Module competency requires: - Evaluation of variable lifecycle: Local vs Global Scope. - Implementation of the global keyword for persistent state management. - Utilization of Lambda expressions for anonymous functional logic. - Application of higher-order functions: map() and filter(). - Development of a multi-stage telemetry data transformer.

Variable Scope and Workspace Isolation

Variable scope defines the accessibility of an identifier within the program hierarchy.

Scope Definitions:

• Global Scope: Identifiers declared at the top-level of a module; accessible by any functional block within that module.
• Local Scope: Identifiers declared within a function block; these are encapsulated and unavailable to external processes once the function execution terminates.

cluster_id = "PROD-01" # Global Variable (Accessible Module-Wide)

def initialize_node():
    node_ip = "10.0.0.1" # Local Variable (Encapsulated)
    print(f"Initializing node {node_ip} in cluster {cluster_id}")

initialize_node()
# print(node_ip) # This raises a NameError as node_ip is not defined in the global namespace.

Namespace Resolution: Local vs Global Scope

• Global Variables: Defined outside any function. Accessible by everyone.
• Local Variables: Defined inside a function. Only accessible inside that function.

score = 0 # Global

def update_score():
    bonus = 10 # Local
    print(f"Local Bonus: {bonus}")

update_score()
print(f"Global Score: {score}")

The global Keyword and State Modification

Functional blocks prioritize local namespace resolution. To modify a global identifier within a local scope, the global keyword must be explicitly invoked.

count = 0

def increment():
    global count # Telling Python: "Use the one outside!"
    count += 1

increment()
print(count) # Output: 1

[!WARNING] Use Sparingly! Relying too much on global makes code hard to debug. It’s usually better to pass variables as arguments and return the result.

Lambda Expressions (Anonymous Functions)

A Lambda is a restricted, single-expression anonymous function. Lambdas are utilized for ephemeral logic where defining a full functional block via def is computationally or syntactically excessive.

Standard Syntax: lambda arguments : expression

# Regular Function
def square(x):
    return x * x

# Lambda Equivalent
square_lambda = lambda x : x * x

print(square_lambda(5)) # Output: 25

Functional Programming Tools: Map and Filter

Lambdas are most powerful when used with functions like map() and filter().

1. map() (Transform everything)

nums = [1, 2, 3, 4]
doubled = list(map(lambda x: x * 2, nums))
print(doubled) # [2, 4, 6, 8]

2. filter() (Keep only what you want)

ages = [15, 20, 18, 12, 30]
adults = list(filter(lambda a: a >= 18, ages))
print(adults) # [20, 18, 30]

Technical Project: Log Telemetry Aggregator

Develop a utility to process a sequence of raw load balancer logs, extracting unique identifiers and applying transformation logic via functional mapping.

# ============================================
# PROJECT: Log Telemetry Aggregator
# ============================================

request_latency = [120, 450, 32, 800, 50, 210]

print("--- Telemetry Processing Engine ---")
print(f"Raw Latency Data (ms): {request_latency}")

# 1. Functional Mapping: Convert ms to seconds
latency_sec = list(map(lambda ms: ms / 1000, request_latency))

# 2. Functional Filtering: Identify high-latency events (> 0.2s)
alert_threshold = list(filter(lambda s: s > 0.2, latency_sec))

# 3. Data Formatting: Append operational units
report_stream = list(map(lambda s: f"EVENT_LATENCY: {s}s", alert_threshold))

print(f"Processed (Seconds): {latency_sec}")
print(f"Critical Events    : {alert_threshold}")
print(f"Report Stream      : {report_stream}")

***

## Assignments

### Assignment 1: Centralized Session Tracking
Define a global integer `active_sessions = 0`.
- Implement a function `register_session()` that increments the global state.
- Invoke the function across multiple iterations and verify the persistent state.

### Assignment 2: Functional IP Filter
Given a sequence of IP addresses: `["10.0.0.1", "192.168.1.1", "10.0.0.50", "172.16.0.5"]`.
- Use `filter()` and a Lambda to extract only addresses belonging to the `10.x.x.x` subnet.
- Use `map()` to append the prefix `[INTERNAL]` to each filtered address.

***

## Knowledge Assessment

**Q1. What is the scope of a variable defined inside a function-**
- A) Global
- B)  Local
- C) Protected
- D) Permanent

**Q2. Which keyword allows a function to modify a variable in the global scope-**
- A) `external`
- B) `outer`
- C)  `global`
- D) `modify`

**Q3. How many expressions can a Lambda function contain-**
- A) Infinite
- B) Two
- C)  Only one
- D) None

**Q4. What does `map()` do-**
- A) Filters out specific items
- B)  Applies a function to every item in a collection
- C) Deletes the collection
- D) Sorts the collection

**Q5. Where does a "Global" variable live-**
- A) Inside a loop
- B) Inside a function
- C)  Outside any function or class
- D) In a separate file only

***

## Technical Evaluation Preparation

### Q1: "What is the LEGB rule in Python�
 **Ideal Answer:**
> "LEGB stands for **Local, Enclosing, Global, and Built-in**. This is the order in which Python looks for a variable. It check the **Local** scope first, then **Enclosing** functions, then the **Global** script level, and finally the **Built-in** library (like `len` or `print`)."

### Q2: "Can a Lambda function contain a 'return' statement�
 **Ideal Answer:**
> "No. A lambda function has an **implicit return**. It automatically returns whatever the expression evaluates to. Including a literal `return` keyword inside a lambda will result in a SyntaxError."

### Q3: "What are the disadvantages of using Global variables�
 **Ideal Answer:**
> "Global variables can lead to 'spaghetti code' where hidden dependencies exist between functions. They make code harder to test because you can't be sure what changed the variable, and they increase the risk of naming collisions. In modern software engineering, they are usually replaced by state-holding objects or class attributes."

***

##  Assignment Solution Key

### 1. Global Counter
```python
total_visits = 0
def track_visit():
    global total_visits
    total_visits += 1

for _ in range(5): track_visit()
print(total_visits)

2. Quick Math

mult = lambda a, b, c: a * b * c
length = lambda s: len(s)
print(mult(2,3,4))
print(length("Python"))

3. Email Filter

emails = ["user@gmail.com", "admin@company.com", "test@gmail.com", "hr@company.com"]
company_only = list(filter(lambda e: "@company.com" in e, emails))
print(company_only)

Module 15: Classes & Objects

Object-Oriented Programming (OOP) and Logical Resource Modeling

Objectives

Module competency requires: - Application of the Object-Oriented Programming (OOP) paradigm for resource management. - Definition of Classes as architectural templates for data structure. - Implementation of Object Instantiation for dynamic resource allocation. - Utilization of the __init__ constructor and the self identifier. - Development of an active infrastructure resource monitor.

Procedural vs. Object-Oriented Design

While procedural programming executes a linear sequence of instructions, Object-Oriented Programming (OOP) encapsulates data (attributes) and logic (methods) into standalone architectural units.

Core Definitions:

• Class: A logical template defining the internal state and operational behavior of an object.
• Object: A specific instance resultant from a class definition, occupying dedicated memory space with unique attribute values.

In an infrastructure context, a Server class may define parameters like cpu_cores and ram_gb, while a specific object prod_srv_01 represents the actual running instance with assigned values.

graph TD
    A[Class: Dog Blueprint] --> B[Object: Tommy]
    A --> C[Object: Bruno]
    B --> D[Name: Tommy, Breed: Husky]
    C --> E[Name: Bruno, Breed: Pug]

Class Definition and the __init__ Constructor

The class keyword initiates the template definition. The __init__ magic method serves as the constructor, executing automatically during object instantiation to configure initial state parameters.

class NetworkNode:
    # Constructor: Initializes instance attributes upon instantiation
    def __init__(self, hostname, role):
        self.hostname = hostname # Attribute: Logical identifier
        self.role = role         # Attribute: Operational role

# Instantiating objects
node_01 = NetworkNode("WEB-PROD-01", "Web-Server")
node_02 = NetworkNode("DB-PROD-01", "Database")

print(f"Active Node: {node_01.hostname}, Role: {node_01.role}")