Join today
Write your awesome label here.
Python for DevOps: The Complete Course
Learn to build robust, production-grade Python applications designed for DevOps workflows. Master automation scripting, testing frameworks, continuous integration and deployment pipelines, and modern development practices to become a confident DevOps engineer.
🏅 Included in the PRO membership!
Write your awesome label here.
225 Lectures
Comprehensive Knowledge
24 Hours
Video Duration
50+ Labs
Focus on Practice
Course Certificate
Validate Your Learning
Course Contents
01
Welcome and Introduction
This introductory section establishes the foundation for the Python for DevOps course. Students will learn the course structure, prerequisites, and learning objectives, including how to navigate course materials, utilize practice exercises and quizzes, and understand the importance of having prior programming experience and DevOps familiarity. The section emphasizes that this is a comprehensive course covering Python fundamentals, advanced topics like generators, decorators, testing, and CI/CD pipelines, and practical DevOps applications rather than a beginner Python course.
Welcome to the Course!
Aligning Expectations
Let's Stay Connected!
Course Resources
02
Setting Up and Running Python
This section covers essential steps in setting Python up for DevOps work, including environment configuration with PyEnv and virtual environments and interactive coding methods (REPL, IPython, JupyterLab).
Section overview
Why Python for DevOps?
Installing and configuring Python
Managing multiple Python installations with pyenv
Overview of virtual environments
Creating our first virtual environment
Managing multiple virtual environments
IMPORTANT! Installing Python 3.12.9 and creating the venv for the course
The Python REPL
Writing and running Python files
Using JupyterLab for interactive code execution
03
Python Fundamentals
This section covers essential Python fundamentals for DevOps, including core data types (variables, numbers, strings), collection types (lists, tuples, sets, dictionaries), control flow (conditionals, loops), efficient iteration patterns (comprehensions, range, enumerate, zip), and function and class definitions with advanced features like *args/**kwargs and lambda functions.
Section overview
Variables
Comments
Numbers
Strings
Hands-on: Disk usage calculation
Introduction to lists
Modifying list contents
Hands-on: Practicing working with lists
Tuples
Introduction to sets
Set operations
Hands-on: Practicing working with sets
Differentiating between lists, tuples, and sets
Introduction to Dictionaries
Dictionary operations
Hands-on: Practicing working with dictionaries
Introduction to conditional code execution
If/elif/else statements
Guard clauses
For and while loops
Break and continue statements
Introduction to list comprehension
List, set, and dictionary comprehension
Introduction to functions
Defining functions and returning values
Parameters and arguments
Docstrings
Hands-on: Practicing working with functions
The range function
Enumerate and ZIP functions
Introduction to classes
Class methods
Inheritance
Introduction to *args and **kwargs syntax
Order in *args and **kwargs arguments
Calling functions: *args and **kwargs
Lambda functions
Sorting collections with lambda
Transforming collections with lambda
Filtering collections with lambda
04
Generators and Decorators
This section covers generators and decorators as foundational Python concepts for writing efficient and reusable code. The learning objectives include understanding the iteration protocol (iterables and iterators), mastering generator functions with the yield keyword, comprehending generator state and exhaustion, building memory-efficient lazy data pipelines, exploring functions as first-class objects, implementing and parameterizing decorators, handling return values and exceptions in decorator wrappers, preserving function metadata with functools.wraps, and applying multiple decorators while understanding their execution order.
Section overview
The iteration protocol
Iterator and iterable code demo
Generator syntax
The yield statement
Pausing and resuming generator execution
State in generators
Generator exhaustion
Return vs. yield statements
Hands-on: Practicing working with generators
Coding lazy pipelines
Functions as first-class citizens
Factory functions
Functions in data structures
Introduction to decorators
Arguments in decorators
Handling return values in decorators
Handling exceptions in decorators
The functools.wraps decorator
Stacking decorators
05
Error Handling and Context Managers
This section covers the fundamentals of exception handling in Python, including try-except-else-finally blocks for handling errors with specific exception types and the EAFP (Easier to Ask for Forgiveness than Permission) design pattern. It explores common built-in exception families like OSError, KeyError, IndexError, ValueError, TypeError, and AttributeError. The section then progresses to raising custom exceptions with context, creating custom exception classes, and finally resource management through context managers including the with statement, the context manager protoco, and creating custom context managers using both class-based and decorator-based approaches.
Section introduction
Exceptions syntax
Thinking in exceptions
Inspecting built-in exceptions
OS and KeyError exceptions
Index, Value, and TypeError exceptions
Attribute and ImportError exceptions
The raise statement
Raising exceptions
Defining custom exceptions
Adding context to custom exceptions
Manual context cleanup
The context manager protocol
Context managers and the "with" statement
Defining custom context managers
The contextmanager decorator
06
Logging for Operations
This section covers Python's logging module fundamentals and advanced logging practices for DevOps. The section teaches the core components of logging (loggers, handlers, formatters, and filters), understanding log levels (debug, info, warning, error, critical), implementing two-stage filtering for log management, writing logs to files with basic and rotating file handlers (both size-based and time-based rotation), structured logging with JSON formatting for machine-readable output, and declarative configuration approaches using INI files, dictionaries, JSON, and dynamic configuration. Students learn how to configure logging to separate concerns between application code and logging setup, enabling flexible and maintainable logging systems.
Section introduction
Why logging?
Introduction to logging anatomy
Hands-on: Practicing logging anatomy
Log levels
File handlers
Rotating log files by size
Rotating log files by time
Structured logging with JSON
Extra fields and exceptions in structured logging
Log configuration with INI files
Log configuration with dictionaries
Log configuration with JSON files
Dynamic log configuration
07
Files, Regex, and Serialization
This section covers modern file operations using pathlib, regular expressions (regex), and data serialization formats. Students learn how to work with the Path object for cross-platform file system operations, master regex patterns for text matching and extraction, and handle JSON, YAML, and CSV data formats for reading and writing configuration and structured data.
Section introduction
The Path object
Listing directory contents, reading and writing files
Read and write modes deep-dive
Read and write methods deep-dive
Regex: Introduction and essentials
Regex: Quantifiers, greedy, and non-greedy search
Regex: Capturing groups
Regex: Non-capturing groups
Regex: Back-references
Regex: findall() and finditer()
Regex: String splitting
Regex: String substitution
JSON deserialization
JSON serialization
Introduction to YAML operations
YAML serialization and deserialization
Reading CSV files
Writing CSV files
08
System Interaction and Automation
This section covers system interaction and automation in Python through four key areas: managing environment variables (accessing, setting, deleting, and loading from .env files), file system management with the OS and Shutil libraries (listing directory contents, creating and deleting files and directories, copying and moving files and directories), creating secure temporary files and directories using the tempfile module, and running external commands through the subprocess module (including capturing output, handling errors, and managing timeouts).
Section introduction
Accessing environment variables
Setting and deleting environment variables
Dotenv files
Listing directory contents
Creating directories
Deleting files and directories
Copying files and directories
Moving files and directories
Temporary files
Temporary directories
Introduction to subprocesses
Handling subprocess errors
Handling expired timeouts
09
Interacting with APIs using requests
This section covers building robust HTTP clients using Python's requests library for DevOps automation. The learning objectives include making HTTP requests (GET, POST with query parameters and JSON payloads), handling responses and HTTP status codes, automatically raising exceptions for errors, implementing authentication using basic auth and token-based authentication, and building resilient API clients with timeout handling, simple retry logic, and advanced retry mechanisms using exponential backoff with jitter.
Section introduction
Creating a GitHub Personal Access Token (PAT)
GET requests
Query parameters
POST requests
HTTP status codes
Raise for HTTP status
Basic authentication
Token-based authentication
Handling timeouts
Retries: Simple strategy
Retries: Exponential backoff with jitter
10
Static Typing and Type Hints
This section covers Python's static typing system and type hints. Students learn why type hints are valuable in dynamically typed Python code and how they improve code readability, enable IDE autocomplete, and allow static type checkers like MyPy to catch errors before runtime. The section covers typing basic types and collections (lists, dicts, tuples, sets, unions, optionals), structured data with TypedDicts, typing custom classes and methods, creating generic functions and classes with TypeVar and type constraints, forward references with string annotations, and advanced patterns like typing decorators with proper function signature preservation and typing generators with yield, send, and return specifications. Throughout the section, the learning objectives emphasize understanding type hints as optional metadata that doesn't affect Python's runtime behavior but significantly improves code quality, maintainability, and IDE support.
Section introduction
[For VS Code Users] - Pylance configuration values I'm using for VS Code
Introduction to type hints
Type hints: Common pitfalls
Typing lists
Typing dictionaries, tuples and sets
Union and optional types
Typed dictionaries
Typing classes
Forward type references
Introduction to generics
Constrained type variables
Bounded type variables
Generics and classes
Typing decorators
Improving decorator types
Typing generators
Typing iterables and iterators
11
Automated Testing with Pytest
This section covers automated testing with PyTest, a comprehensive framework for writing and organizing tests in Python. The material progresses from fundamentals including assertions and test configuration through advanced topics like fixtures for managing test setup and teardown, parametrization for data-driven testing, and mocking techniques for isolating code under test. The section emphasizes best practices for writing maintainable, deterministic, and robust automated tests that validate both individual functions and complex integrations.
Section introduction
Assertions in Pytest
Hands-on: Test-driven implementation
Inspecting failure output and float approximation
Testing exceptions
Marking tests as expected failures
Pytest configuration
Skipping tests
Indicating expected failures
Custom markers
Introduction to fixtures
Fixture scopes
Sharing fixtures in conftest.py
Introduction to parametrization
Using the param function
Mocking fundamentals
Patch decorator and mocker fixture
Configuring mock objects
Setting exceptions and lists as side effect
Using callable as side effect
Mock vs. MagicMock
12
Structuring Python Projects
This section covers the fundamentals of structuring Python projects across multiple files and directories. It explores the module and package systems, the import mechanisms and how Python locates modules, organizing code hierarchically with packages and sub-packages, distinguishing between absolute and relative imports, running code from packages using command-line modules, defining project metadata and creating installable packages, and organizing and executing tests within multi-file projects.
Section introduction
Python modules
Python packages
Introduction to subpackages
Absolute vs. Relative imports
Common import errors and how to fix them
Running Python modules
Pyproject.toml file
Adding tests to multi-file projects
13
CI/CD for Python Projects
This section covers the complete implementation of a continuous integration and continuous deployment pipeline for Python projects. The core concepts include setting up automated workflows with GitHub Actions to perform quality checks on code, running tests across multiple Python versions, building distributable packages, and automatically publishing libraries to package repositories. The section demonstrates how to integrate multiple development tools for linting, formatting, type checking, and security analysis into an automated workflow, along with implementing test automation frameworks and establishing semantic versioning for releases. The entire pipeline is designed to automate code quality verification, testing, building, and publishing with minimal manual intervention.
Section introduction
Introduction to click
CI/CD tooling for our project
CI/CD pipeline overview
Setup GitHub repository and local environment
Implementation plan overview
Creating our pyproject.toml file
Implementing the HTTP checker module
Implementing the CLI script - Part 1
Implementing the CLI script - Part 2
GitHub Actions - Deploy minimal workflow
Add linting and format checks
Add static type and security checks
Pytest - Setup and configuration
Pytest - Implement HTTP checker tests
Pytest - Implement CLI tests
Pytest - Integrate automated tests in the workflow
Building the Python library
Configuring PyPI account and OIDC information
Configure Semantic Release
Integrate Semantic Release in the workflow
Publishing to TestPyPI
Publishing to PyPI
Optimize workflow to leverage release assets
14
Conclusion
Congratulations!
Certificate of Completion
Frequently asked questions
Who is this course designed for?
This course is designed for multiple technical roles seeking to deepen their Python and DevOps expertise.
What prior knowledge do I need before taking this course?
You should have foundational programming experience with any language, as the course assumes comfort with basic programming concepts like variables, functions, loops, and conditional logic. Basic familiarity with the command line and terminal usage is highly recommended, as you will work extensively with Python tools, virtual environments, and GitHub Actions.
No prior experience with DevOps, CI/CD pipelines, or advanced Python concepts is required. The course starts from fundamentals and progressively builds your knowledge through hands-on exercises. You should be comfortable reading technical documentation and willing to follow along with code examples.
No prior experience with DevOps, CI/CD pipelines, or advanced Python concepts is required. The course starts from fundamentals and progressively builds your knowledge through hands-on exercises. You should be comfortable reading technical documentation and willing to follow along with code examples.
Will I incur costs (cloud provider/tools) while taking this course?
The entire course can be completed entirely for free using open-source tools and free services.
Free Components:
Free Components:
Do I need to be a command line expert to succeed in this course?
No, you do not need to be a command line expert, but you should be comfortable with basic terminal operations. The course includes guidance on terminal usage throughout, and you will naturally become more comfortable with the command line through extensive hands-on practice with Python tools, virtual environments, and GitHub Actions.
The focus of this course is on building Python skills and DevOps workflows, not on terminal mastery. You will learn the specific commands and workflows you need as you progress through the course. If you are completely new to the command line, spending a few hours learning basic navigation and file operations beforehand will help you get more value from the course.
The focus of this course is on building Python skills and DevOps workflows, not on terminal mastery. You will learn the specific commands and workflows you need as you progress through the course. If you are completely new to the command line, spending a few hours learning basic navigation and file operations beforehand will help you get more value from the course.
What makes this course different from other Python or DevOps courses?
This course takes a unique approach by combining comprehensive Python education with real DevOps practices. Rather than teaching Python in isolation or focusing only on operations, this course shows how Python developers and DevOps engineers use Python together in professional environments.
The course emphasizes learning by doing through extensive hands-on projects, including a complete CI/CD pipeline project where you implement linting, formatting, testing, type checking, security scanning, automated release workflows, and package publishing. You will not just learn concepts, you will build the exact workflows used in production systems. The progression from fundamentals to advanced topics ensures you understand how concepts connect, and the focus on DevOps applications throughout keeps everything grounded in real-world relevance.
The course emphasizes learning by doing through extensive hands-on projects, including a complete CI/CD pipeline project where you implement linting, formatting, testing, type checking, security scanning, automated release workflows, and package publishing. You will not just learn concepts, you will build the exact workflows used in production systems. The progression from fundamentals to advanced topics ensures you understand how concepts connect, and the focus on DevOps applications throughout keeps everything grounded in real-world relevance.