Python for DevOps: Day 3 — Keywords, Variables, and Best Practices

This chapter explores the foundational building blocks of Python programming: Keywords and Variables. You will learn how Python uses reserved words to construct execution logic, how variables store and manage data dynamically, how variable scope (global vs. local) affects code execution, and the industry-standard naming conventions that distinguish production-grade scripts from amateur code.

1. Recap of Day 1 & Day 2

Before diving into keywords and variables, it is essential to contextualize where these concepts sit in your Python journey.

• Day 1 (Introduction to Python for DevOps): We established why Python is preferred over Shell scripting for complex automation, explored popular DevOps use cases (such as cloud resource provisioning and API integrations), installed Python, and executed our first script.
• Day 2 (Data Types & Manipulations): We explored data types, focusing heavily on Strings and Numeric types (Integers and Floats). We learned that mastering string manipulation functions and built-in methods is critical for parsing logs, handling configuration files, and passing technical interviews.

2. The Four Pillars of Programming

To master any programming language, you must understand its core architecture. Every language is built upon four fundamental pillars:

1. Keywords: The reserved words that define the language's syntax, structure, and control flow.
2. Data Types: The classifications of data (e.g., Strings, Integers, Floats, Lists, Dictionaries) that dictate what values a variable can hold and what operations can be performed on them.
3. Operators: The symbols used to perform operations on variables and values (e.g., arithmetic, comparison, and logical operators).
4. Logical Reasoning: The ability to combine keywords, data types, and operators to solve real-world problems. This skill cannot be memorized; it is developed through daily practice and script writing.

3. What are Keywords?

Keywords are reserved words in Python that have a predefined, specific meaning to the Python interpreter. Because they are reserved, you cannot use them as names for your variables, functions, classes, or any other user-defined identifiers.

Real-Life Analogy: Verbs in English

Think of keywords as verbs in the English language. If you are asked to write a coherent sentence, it is nearly impossible to do so without using a verb (e.g., "run", "is", "write").

Similarly, in Python, while you can write a trivial script like print("Hello World") without explicit control-flow keywords, you cannot build real-world, production-grade automation logic (such as conditional loops, error handling, or cloud resource filtering) without using keywords.

4. The 26 Essential DevOps Python Keywords

While Python has several built-in keywords, DevOps engineers frequently use a core subset of 26 keywords to handle automation, scripting, and cloud infrastructure management.

Code Example: Spotting Keywords in a Real Script

Below is a typical script that deletes records from a file. Notice how keywords form the structural skeleton of the code:

import os  # 'import' is a keyword

def delete_old_logs(file_path):  # 'def' is a keyword
    if os.path.exists(file_path):  # 'if' is a keyword
        with open(file_path, 'w') as file:  # 'with' is a keyword
            file.write("")
            print("Logs cleared successfully.")
    else:  # 'else' is a keyword
        print("File not found.")

5. What is a Variable?

A variable is a named storage location in memory used to hold data that can be referenced and manipulated throughout a program.

Naive vs. Better Approach

To understand why variables are indispensable, let us look at two ways to print an EC2 instance name.

The Naive Approach (Hardcoded)

print("project-xyz-instance")

While this works for a single line, hardcoding values becomes a maintenance nightmare in large scripts.

The Better Approach (Using a Variable)

ec2_instance_name = "project-xyz-instance"
print(ec2_instance_name)

Here, ec2_instance_name is the variable, = is the assignment operator, and "project-xyz-instance" is the string value stored in memory.

6. Statically vs. Dynamically Typed Languages

Languages handle variables in two primary ways: Static Typing and Dynamic Typing.

Code Comparison

Go (Statically Typed):

var name string = "abhishek"

Python (Dynamically Typed):

name = "abhishek"
x = 6
is_active = True

In Python, you do not need to write str name = "abhishek" or int x = 6. The interpreter dynamically assigns the type.

7. Real-World DevOps Use Case: Why Variables Prevent Production Outages

Imagine you have a Python script containing 1,000 lines of code that interacts with an AWS EC2 instance named project-xyz-instance. This instance name is referenced 25 times throughout the script (e.g., in lines 1, 25, 500, 600, 700, and 1000).

The Problem

Your organization decides to rename the instance from project-xyz-instance to project-abc-instance.

• Without Variables: You must manually search through all 1,000 lines of code and update the name in 25 different places. If you or a teammate misses even one reference (e.g., on line 700), the script will fail halfway through execution, potentially causing a production outage or leaving infrastructure in an inconsistent state.
• With Variables: You declare the variable once at the very top of your script:

# Declare once at the top of the script
ec2_instance_name = "project-xyz-instance"

# Reference the variable throughout the script
print(ec2_instance_name)  # Line 25
print(ec2_instance_name)  # Line 500

If the instance name changes, you only modify line 1 to ec2_instance_name = "project-abc-instance". The change automatically propagates to all 25 references.

Key Benefits of Variables

1. Reduces Maintenance Time: Changes are made in a single location.
2. Eliminates Human Error: Prevents partial updates where some hardcoded values are missed.

8. Variable Scope: Global vs. Local Variables

Variable scope determines where in your script a particular variable can be accessed or modified.

• Global Variables: Declared outside of any function block (typically at the top of the script). They are accessible by any function or block of code within that entire file.
• Local Variables: Declared inside a specific function block. They are isolated and can only be accessed or modified within that specific function. Other functions cannot see or use them.

9. Step-by-Step Code Evolution: Scope in Action

Let us write a simple calculator script to demonstrate how global and local scopes behave in Python.

Scenario A: Using Global Variables

In this scenario, variables a and b are declared globally. Both the addition and subtraction functions can access them.

# Global Variables
a = 10
b = 5

def addition():
    # Accesses global variables 'a' and 'b'
    print(a + b)

def subtraction():
    # Accesses global variables 'a' and 'b'
    print(a - b)

# Executing the functions
addition()     # Output: 15
subtraction()  # Output: 5

Scenario B: Using Local Variables (The Error Case)

In this scenario, we declare a and b locally inside the addition function.

def addition():
    # Local Variables (isolated to addition)
    a = 10
    b = 5
    print(a + b)

def subtraction():
    # This will throw a NameError because 'a' and 'b' are not defined in this scope
    print(a - b)

addition()     # Output: 15
subtraction()  # Raises NameError: name 'a' is not defined

Why did it fail? The variables a and b are local to addition(). The moment addition() finishes executing, those variables are cleared from memory. When subtraction() attempts to access a and b, Python cannot find them, resulting in a runtime crash.

Scenario C: Mixing Global and Local Scope Correctly

To fix the error while keeping local variables isolated, we can define a local variable c that is only needed for the addition logic, while keeping other variables scoped correctly.

# Global Variables
a = 10
b = 5

def addition():
    c = 10  # Local variable, only used here
    print(a + b + c)

def subtraction():
    print(a - b)  # Only uses global variables

addition()     # Output: 25 (10 + 5 + 10)
subtraction()  # Output: 5  (10 - 5)

10. Variable Naming Conventions & Best Practices

Writing production-grade code requires adhering to strict naming conventions. If you do not follow these rules, experienced engineers and interviewers will immediately recognize a lack of real-world experience.

Rule 1: Always Use Lowercase for Standard Variables

Avoid using uppercase letters for standard variables.

• Bad: NAME = "Abhishek"
• Good: name = "Abhishek"

Note: In Python, all-caps variable names (e.g., PORT = 8080, DB_HOST = "localhost") are reserved by convention for constants (values that should never change during the execution of the script).

Rule 2: Use Snake Case or Camel Case for Multi-Word Variables

When a variable name consists of multiple words, do not run them together. Use a clear casing convention.

• Snake Case (Highly Recommended in Python): Separate words with underscores.
  PYTHON

  Copy

  ec2_instance_name = "project-xyz-instance"
  full_name = "Abhishek Veeramalla"
  

• Camel Case: Capitalize the first letter of each word except the first.
  PYTHON

  Copy

  ec2InstanceName = "project-xyz-instance"
  fullName = "Abhishek Veeramalla"
  

Rule 3: Make Variable Names Descriptive

Your variable names should describe the data they hold. Avoid overly short, cryptic names.

• Bad: n = "Abhishek" (What does n mean? Name? Node? Number?)
• Bad: fn = "Abhishek"
• Good: first_name = "Abhishek"
• Good: s3_bucket_name = "my-prod-logs"

Exception: It is acceptable to use short, single-letter variable names (like i, j, x, y) inside simple loop constructs (e.g., for i in range(10):), as their context is immediate and temporary.

Summary and Key Takeaways

• The Four Pillars: Mastering any language requires learning its Keywords, Data Types, Operators, and developing Logical Reasoning through practice.
• Keywords are Reserved: Keywords are the structural "verbs" of Python. They cannot be used as variable names.
• Dynamic Typing: Python is dynamically typed, meaning you do not need to declare variable types (like string or int) beforehand.
• Variables Prevent Errors: Variables eliminate hardcoded values, reducing maintenance overhead and preventing human error during updates.
• Global vs. Local Scope: Global variables are declared outside functions and are accessible everywhere. Local variables are declared inside functions and are isolated to those functions.
• Snake Case is Standard: Use lowercase letters and underscores (snake_case) for multi-word variables in Python.
• Be Descriptive: Choose descriptive names like ec2_instance_name over cryptic abbreviations like ein to ensure your code is readable and maintainable.