Python Notes — Basics to DevOps Automation

# Your very first Python program
print("Hello Python")
# Output: Hello Python

What is Python & Why Learn It

• Interpreted: code runs line by line, no compile step — you see results instantly.
• Why popular: English-like syntax means beginners write working programs in their first hour.
• Where it's used: Instagram's backend, NASA data analysis, AI models, Ansible automation.
• DevOps connection: boto3 (AWS SDK), Ansible itself, and most CI/CD glue scripts are Python.

# Check if Python is already installed
python3 --version
# Output: Python 3.11.4

Install Steps by OS

• Linux (Ubuntu/Debian): usually pre-installed; if not, sudo apt install python3
• Windows: python.org/downloads → tick "Add Python to PATH" (most common mistake: forgetting this).
• Mac: pre-installed, but get the latest via brew install python3
• Run a file: save as hello.py, run with python3 hello.py

# Comments start with #
if True:
    print("Indented = inside the if block")
print("Not indented = outside the block")

Indentation & Syntax Rules

• Indentation is mandatory: 4 spaces, never tabs — mixing both causes errors.
• No semicolons: statements end at the newline.
• Case-sensitive: Name and name are different variables.
• Common error: IndentationError: expected an indented block — forgot to indent after :

name = "Devriston"   # str
age = 25             # int
price = 99.50        # float
is_active = True     # bool
print(name, age, price, is_active)

• str: text, wrapped in quotes — single or double, same result.
• int / float: whole numbers vs decimal numbers.
• bool: only True or False (capitalised).
• Convert types: int("25"), str(25), float("9.5")

name = input("Enter your name: ")
age = int(input("Enter your age: "))
print(f"Hello {name}, you are {age} years old")

• input() is always a string: wrap with int() before doing math.
• f-strings: f"Hello {name}" — cleanest way to insert variables into text.
• Common bug: forgetting the conversion causes TypeError: can't add str and int

x = 10
y = 3
print(x + y)   # 13 — addition
print(x % y)   # 1  — remainder
print(x > y)   # True — comparison

• Arithmetic: + - * / // % **
• Comparison: == != > < >= <= always return True/False.
• Logical: and, or, not
• Common confusion: = assigns, == compares — #1 beginner bug.

age = 20
if age >= 18:
    print("Adult")
elif age >= 13:
    print("Teenager")
else:
    print("Child")

• if: runs only if condition is True, always ends with :
• elif: checked only if previous was False — chain as many as needed.
• else: fallback — runs if nothing above matched.

for i in range(5):
    print("Count:", i)
# Prints Count: 0 through Count: 4

• range(5): generates 0–4 — stops BEFORE 5, a very common beginner trap.
• break: exits the loop completely. continue: skips to next repeat.
• Infinite loop warning: always make sure the while condition changes inside the loop.

def greet(name):
    print(f"Hello, {name}!")

greet("Kamran")
# Output: Hello, Kamran!

• def: defines a function — it only runs when called by name.
• return: sends a value back; without it a function returns None
• Default parameters: def greet(name="Guest") lets you call with no argument.

fruits = ["apple", "banana", "mango"]
print(fruits[0])   # apple
fruits.append("grape")

server = {"host": "web-01", "port": 80, "active": True}
print(server["host"])  # web-01

• List [ ]: ordered, changeable — most commonly used collection.
• Tuple ( ): ordered, unchangeable — fixed data like coordinates.
• Dict {key: value}: instant lookup by key — the foundation of JSON data.
• Set { }: unordered, auto-removes duplicates — useful for deduplication.

try:
    value = int(input("Enter a number: "))
    print(100 / value)
except ZeroDivisionError:
    print("Can't divide by zero")
except ValueError:
    print("That wasn't a number")
finally:
    print("Done checking input")

• try: code that might fail goes here.
• except: catches a specific error type — be specific, don't use a bare except:
• finally: always runs — close files, release locks, log "attempt finished".
• Real use case: a server-check script shouldn't crash because one host is unreachable.

# Writing and reading a file
with open("status.log", "a") as f:
    f.write("Service checked: OK\n")

with open("status.log", "r") as f:
    for line in f:
        print(line.strip())

• with open(...) as f: auto-closes the file even if an error happens — always prefer this.
• Modes: "r" read, "w" overwrite, "a" append.
• pathlib: modern way to handle paths — from pathlib import Path works across Linux/Windows.

# Create and activate a virtual environment
python3 -m venv venv
source venv/bin/activate

# Install and freeze dependencies
pip install requests
pip freeze > requirements.txt
pip install -r requirements.txt

• venv: a private copy of Python + packages per project — no version conflicts between projects.
• requirements.txt: lets anyone (or any CI pipeline) recreate your exact environment.
• import: use import os for built-ins — no install needed for the standard library.

import requests, json

response = requests.get("https://api.github.com/users/octocat")
data = response.json()
print(data["login"], data["public_repos"])

# Reading a local JSON config (works offline)
with open("config.json") as f:
    config = json.load(f)
print(config["server_name"])

• requests: the standard library for HTTP APIs — install with pip install requests
• .json(): converts an API response straight into a Python dictionary.
• json.load() / json.dump(): read and write JSON files for configs or saved state.

import os, subprocess

# Read an env var — never hardcode secrets in scripts
api_key = os.environ.get("API_KEY", "not set")

# Run a shell command and capture output
result = subprocess.run(
    ["df", "-h", "/"],
    capture_output=True,
    text=True,
    check=True    # raises CalledProcessError if command fails
)
print(result.stdout)
print("Exit code:", result.returncode)  # 0 = success

• os.environ: read env vars and secrets — never hardcode API keys in the script.
• os.listdir() / os.path: walk directories, check if files or paths exist.
• subprocess.run(): the safe modern way to call shell commands — captures exit codes, stdout, stderr.
• check=True: raises CalledProcessError if the command fails — always use in production scripts so errors are never silently ignored.
• sys.argv: read command-line arguments so your script can be reused with different inputs.