Python for DevOps: Mastering Real-World Automation

This lecture provides an overview of the different topics covered in this section.

This lecture introduces the key reasons why Python is an excellent choice for DevOps and automation tasks. You'll learn about its simplicity, extensive libraries, and cross-platform compatibility, making it the perfect "glue" language for modern infrastructure.

Learn the importance of managing multiple Python versions without interfering with your operating system's default installation. This lecture explains how to use pyenv to install and switch between different Python versions, setting the foundation for a professional development setup.

This lecture provides a practical guide to installing and verifying pyenv on your system. You'll learn how to use the command line to ensure pyenv is configured correctly and ready to manage your Python installations.

Understand why virtual environments are essential for managing project-specific dependencies and avoiding conflicts. This lecture visually explains how venv isolates package installations for different projects, ensuring a clean and reproducible setup.

Get hands-on experience creating and activating your first Python virtual environment using the venv module. You will learn the commands to turn the environment on (source .venv/bin/activate) and off (deactivate).

Discover how dependencies installed in one virtual environment remain completely isolated from another. This lecture demonstrates how to manage different sets of packages and how to create a requirements.txt file to ensure your project's dependencies are reproducible.

Let's make sure we all have the same setup for the smoothest learning experience. This lecture provides the necessary steps for you to setup the course's Python version and dependencies.

Learn about the Read-Eval-Print Loop (REPL) as the most direct way to interact with Python. You'll explore both the standard Python REPL and the more powerful IPython for quick, interactive coding sessions.

This lecture explains how to write and execute Python scripts from a .py file. You'll understand the key difference between an interactive REPL and a script, and learn how to use the print() function to see output.

Discover JupyterLab as a powerful, web-based environment for writing Python code. You'll learn how to create notebooks composed of code cells and markdown text, making it ideal for exploratory work and documenting processes.

This lecture provides an overview of the different topics covered in this section.

Learn the fundamentals of creating and using variables in Python to store and reference data. This lecture covers naming conventions (snake_case) and Python's dynamic typing system.

Understand how to effectively use single-line (#) and multi-line ("""...""") comments to document your code. You'll learn that good comments explain the "why," not the "what," of your code.

This lecture covers the two primary numeric types in Python: integers (whole numbers) and floats (decimal numbers). You'll learn about standard arithmetic operators and how to handle floating-point precision issues using math.isclose.

Discover how to work with strings, which are immutable sequences of characters. You'll learn about f-strings for easy formatting and explore essential string methods like .strip(), .split(), and .join().

Apply your knowledge of variables, numbers, and strings in a practical exercise. You'll write a script to calculate disk usage percentage and format the output into a human-readable summary.

Learn about lists, which are ordered, mutable collections perfect for storing sequences of items. This lecture covers how to create a list, access items by their index, and perform slicing to extract sub-lists.

Discover the common methods used to modify lists in-place, such as .append(), .insert(), .pop(), and .remove(). You'll also learn how these mutating operations can have side effects if not handled carefully.

Put your list knowledge into practice with a hands-on exercise. You will create a list of deployment targets, then append, access, and modify its elements to solidify your understanding.

This lecture introduces tuples, which are ordered, immutable collections ideal for fixed-record data like coordinates or host-port pairs. You'll learn how their immutability prevents accidental modification after creation.

Discover sets, which are unordered, mutable collections of unique items. You'll learn how sets automatically handle deduplication and are highly optimized for membership testing.

Learn how to perform powerful mathematical set operations to compare and combine collections. This lecture covers union (|), intersection (&), and difference (-) to find shared or unique items between two sets.

Practice using sets in a real-world scenario by managing software package dependencies. You'll use set operations to calculate missing, extra, and common packages between two different sets.

This summary lecture provides a clear comparison of lists, tuples, and sets based on their core characteristics. You'll understand the key use cases for each collection type, helping you choose the right tool for the job.

Learn about dictionaries, which are mutable collections of key-value pairs, making them perfect for lookups and structured data. This lecture covers how to create dictionaries and access their keys, values, and items.

Discover how to effectively manipulate dictionaries with common operations. You'll learn how to safely get values, merge dictionaries using the union operator (|), and add or update key-value pairs.

Apply your dictionary skills in a practical exercise by creating a nested dictionary to store server information. You'll practice retrieving, updating, and iterating over its contents to build your confidence.

This lecture introduces the core concepts of conditional execution in Python using if, elif, and else. You'll also learn about truthy and falsy values, which allow you to write more concise conditional checks.

Get hands-on with conditional statements to control the flow of your scripts. You'll learn how to use comparison operators and chain multiple conditions together to handle different scenarios.

Discover guard clauses as a practical pattern for validating function inputs and handling edge cases early. This technique helps you avoid deeply nested if/else blocks, leading to cleaner and more readable code.

Learn the two primary ways to perform repeated actions in Python. You'll use for loops to iterate over known sequences and while loops to repeat a block of code as long as a condition is true.

Discover how to control the flow of your loops with the break and continue keywords. You'll learn to use break to exit a loop early and continue to skip the current iteration and move to the next.

Learn about list comprehensions as a concise and readable way to create lists. This lecture shows how to replace verbose for loops with a single, elegant line of code.

Discover how to add conditional logic to your comprehensions to filter items. You'll also learn that the same powerful syntax can be used to create sets and dictionaries.

This lecture breaks down the anatomy of a Python function, from its definition and parameters to its docstring and return statement. Understanding this structure is key to writing reusable and maintainable code.

Get hands-on with defining your own functions using the def keyword. You'll learn how to use the return statement to send a result back to the caller, making your functions powerful building blocks.

Understand the difference between parameters (in the function definition) and arguments (the values passed during a call). This lecture covers how to use both positional and keyword arguments to make your function calls more flexible.

Learn the importance of docstrings for documenting your functions. You'll see how a well-written docstring explains a function's purpose, parameters, and return value, and can be accessed with the help() function.

Solidify your understanding of functions by completing three practical exercises. You'll write functions to greet multiple users, sum even numbers from a list, and generate the Fibonacci sequence.

Discover the range() function as a memory-efficient way to generate a sequence of numbers for looping. You'll learn why using range() is far more performant than creating a large list of numbers in memory.

Learn about two powerful built-in functions for iteration. You'll use enumerate to get both the index and the item while looping, and zip to iterate over multiple sequences in parallel.

This lecture introduces classes as blueprints for creating your own custom objects. You'll learn the basic syntax for defining a class, initializing its attributes with __init__, and creating instances.

Discover how to define behavior for your objects by creating class methods. You'll learn that the first parameter of any method is always self, which provides a reference to the instance itself.

Learn about class inheritance as a way to create a new class that inherits attributes and methods from a parent class. This lecture covers the basic syntax for creating subclasses and how to use super() to call methods from the parent.

This lecture demystifies the *args and **kwargs syntax for creating functions that accept a variable number of arguments. You'll learn that *args collects positional arguments into a tuple, while **kwargs collects keyword arguments into a dictionary.

Understand the proper order for defining parameters in a function that mixes standard arguments, *args, and **kwargs. This lecture clarifies the syntax rules to ensure your function signatures are valid and predictable.

Discover how you can use the * and ** operators to unpack collections when calling a function. This allows you to pass arguments dynamically from a list or dictionary, making your code more flexible.

This lecture introduces lambda functions as a concise way to create small, anonymous functions using a single expression. You will learn the basic syntax, which starts with the lambda keyword followed by arguments, a colon, and the expression to be returned.

Discover a common and powerful use case for lambda functions: providing a custom sorting key to the built-in sorted() function. This lecture shows how to use a lambda to sort a list of complex objects based on a specific attribute without defining a separate, named function.

Learn how to use the map() function in combination with a lambda to apply a transformation to every item in an iterable. This provides a concise, functional approach to creating a new iterator with the modified results.

This lecture explains how to use the filter() function along with a lambda to selectively keep items from an iterable. You will see how this pattern allows you to create a new iterator containing only the elements for which the lambda function returns true.

This lecture provides an overview of the different topics covered in this section.

This lecture explains the fundamental mechanism that powers for loops in Python. You'll learn about the two key components, iterables (with __iter__) and iterators (with __next__), which together form the iteration protocol.

Get a hands-on understanding of the difference between an iterable and an iterator by seeing how they behave in nested loops. This lecture demonstrates why decoupling the iterable from the iterator is crucial for creating independent, stateful iterations.

This lecture introduces generator functions as a simpler, more concise way to create iterators. You'll learn that any function containing the yield keyword becomes a generator, which can be iterated over one value at a time.

Dive deeper into the yield keyword and how it differs from return. You'll see how yield produces a value and pauses the function's execution, preserving its state for the next iteration.

This lecture provides a clear, step-by-step demonstration of the pause-and-resume nature of generators. You'll see exactly when a generator's code executes in response to calls to next(), making the control flow easy to understand.

Understand one of the most powerful features of generators: their ability to preserve state between yield calls. This lecture explains how local variables inside a generator function are remembered across iterations.

Learn what happens when a generator has no more values to yield. This lecture explains how a StopIteration exception is raised, which signals the end of the iteration to constructs like for loops.

This lecture provides a direct comparison between regular functions that return a single, complete result (eager evaluation) and generator functions that yield values one by one (lazy evaluation). You'll understand the fundamental difference in their execution models and memory usage.

See the practical benefits of lazy evaluation in a hands-on exercise. By timing both a regular function and a generator, you'll witness firsthand how generators can deliver the first piece of data much faster and with lower memory overhead.

Discover how to chain multiple generators together to create powerful and memory-efficient data processing pipelines. This lecture demonstrates how each stage of the pipeline processes one item at a time without creating large intermediate lists.

This lecture introduces the concept of functions as "first-class citizens" in Python. You'll learn how to assign functions to variables and pass them as arguments to other functions, enabling more dynamic and flexible code.

Discover the factory pattern, where one function is used to create and return another, customized function. You'll see how the returned function "remembers" variables from its creation scope, a concept known as a closure.

Learn that you can store functions in data structures like lists and dictionaries, just like any other object. This powerful technique is the foundation for implementing patterns like plugin registries and dynamic dispatch tables.

This lecture introduces decorators as an elegant way to add functionality to existing functions without modifying their code. You'll learn the basic pattern of a decorator: a function that takes a function, wraps it in another function, and returns the wrapper.

Learn how to create configurable decorators by using the "decorator factory" pattern. This involves adding an outer function that accepts arguments and returns the actual decorator, allowing you to customize its behavior.

Understand the importance of correctly handling return values inside a decorator's wrapper function. This lecture shows you how to capture the result of the original function call and return it, ensuring the decorator is transparent to the caller.

Learn the best practice for handling exceptions that may be raised by a decorated function. You'll see why it's crucial to catch and then re-raise the exception to avoid silently swallowing errors and hiding bugs.

Discover a common pitfall of decorators: they can lose the original function's metadata, like its name and docstring. This lecture shows you how to use the @functools.wraps decorator to preserve this important information.

Learn how to apply multiple decorators to a single function by "stacking" them. You'll understand that the order of decorators matters, as they are applied from the bottom up, creating nested layers of wrappers.

This lecture provides an overview of the different topics covered in this section.

This lecture introduces the fundamental syntax for handling errors in Python. You'll learn about the try, except, else, and finally blocks and the specific role each one plays in creating robust code.

Discover a powerful design pattern for writing cleaner, more readable code. This lecture compares the "look before you leap" approach with the "easier to ask for forgiveness than permission" approach, showing how try/except blocks can simplify control flow.

Explore the rich hierarchy of built-in exceptions that Python provides. You'll learn how to write a script to inspect this hierarchy, helping you understand which exceptions to catch in your code.

This lecture covers two of the most common exception families you'll encounter in DevOps automation. You'll learn how to handle file system and I/O errors with OSError and its subclasses, and how to safely access dictionary keys to avoid KeyError.

Understand the key differences between three common data-related exceptions. You'll learn to handle IndexError for out-of-bounds sequence access, ValueError for invalid argument values, and TypeError for operations on incompatible types.

This lecture covers two more common exceptions. You'll learn how to handle AttributeError when accessing a non-existent attribute on an object, and ImportError (or ModuleNotFoundError) when a module cannot be located.

Learn how to proactively signal a failure in your code by using the raise statement. This lecture explains why raising an exception is often a clearer and more robust way to handle errors than returning special values like None.

Discover how to raise specific built-in exceptions like TypeError and ValueError to enforce preconditions in your functions. This technique allows you to provide immediate, clear feedback when your functions are used incorrectly.

Learn why and how to create your own custom exception classes by subclassing Python's base Exception class. This allows you to create more meaningful and specific error types that are relevant to your application's domain.

Discover how to add valuable context to your custom exceptions by overriding the __init__ method. You'll learn how to capture and store relevant information, making your error messages far more useful for debugging.

This lecture demonstrates the traditional way of ensuring resources are cleaned up using a try...finally block. You'll see that while this pattern works, it can be verbose and error-prone.

This lecture introduces the protocol that enables the with statement for automatic resource management. You'll learn about the two essential methods, __enter__ for setup and __exit__ for teardown, that any class must implement to function as a context manager.

Learn about the with statement as a cleaner, more robust alternative to try...finally for managing resources. This lecture shows how context managers automatically handle setup and teardown, even when errors occur.

Discover how to create your own context managers by implementing a class with __enter__ and __exit__ methods. This gives you full control over the setup and teardown logic for your custom resources.

Learn a simpler way to create a context manager using the @contextlib.contextmanager decorator. This allows you to define the setup and teardown logic within a single generator function, separated by a yield statement.

This lecture provides an overview of the different topics covered in this section.

This lecture introduces the fundamental importance of logging in DevOps for troubleshooting, auditing, and monitoring. You'll understand why structured logging is far superior to simple print statements for building observable applications.

Discover the core components of Python's logging module. This lecture breaks down the roles of Loggers, Handlers, and Formatters, and explains the hierarchical structure that makes the framework so powerful.

Get hands-on with the core components of the logging module. You will learn how to get a logger instance, inspect its properties, attach a handler, and apply a formatter to control the output.

Understand the five standard log levels (DEBUG, INFO, WARNING, ERROR, CRITICAL) and how they are used to control log verbosity. This lecture explains the two-stage filtering process, where messages are first checked at the logger level and then at the handler level.

Learn how to direct your log output to a file using the FileHandler. You'll understand how to configure the file mode to either append to or overwrite existing log files.

Discover how to manage log file growth using the RotatingFileHandler. This lecture shows you how to automatically rotate logs once they reach a certain size and how to configure the number of backup files to keep.

Learn how to rotate logs based on a time interval using the TimedRotatingFileHandler. You'll see how to configure rotations to occur every second, minute, hour, or day, making it easy to manage time-based log archives.

This lecture introduces structured logging and its benefits for machine parsing and analysis. You'll learn how to use the python-json-logger library to easily format your log records as JSON objects.

Discover how to enrich your structured logs by adding custom contextual fields to your JSON output. You'll also learn how to correctly log exceptions to ensure the full traceback is included in the log record.

Learn how to configure your logging setup declaratively using an .ini file. This lecture shows you how to define loggers, handlers, and formatters in a configuration file, separating your logging setup from your application code.

Discover a more flexible way to configure logging using a Python dictionary. You'll learn how to use logging.config.dictConfig to apply a configuration defined as a dictionary object.

Learn how to externalize your logging configuration by storing it in a JSON file. This lecture shows you how to load the JSON file into a dictionary and then apply it using dictConfig.

Discover how to dynamically build or modify your logging configuration at runtime. This powerful technique allows you to change log levels or handlers based on environment variables or other conditions.

This lecture provides an overview of the different topics covered in this section.

This lecture introduces the pathlib module as a modern, object-oriented way to handle file system paths. You will explore the Path object and its useful attributes like .parent, .name, and .suffix, which make path manipulation cleaner and more reliable.

Learn how to use pathlib to interact with the file system. You'll discover how to list directory contents with iterdir() and glob(), and how to perform basic file I/O with read_text() and write_text().

This lecture provides a detailed overview of the different file modes (read, write, append, exclusive) available in Python. You will learn how to use these modes with the open() method to control how you interact with text files.

Discover the various methods for reading and writing file content. You'll learn the difference between reading a file line-by-line, reading the entire file at once with .read(), and writing multiple lines with .writelines().

This lecture covers the fundamentals of regular expressions for powerful text pattern matching. You will learn about metacharacters, character classes, and special sequences like \d (digits) and \w (word characters).

Understand how quantifiers (*, +, ?) control how many times a pattern can occur. You'll learn the crucial difference between greedy matching (longest possible match) and non-greedy matching (shortest possible match).

Discover how to use capturing groups (defined with parentheses) to extract specific pieces of information from a matched string. You'll also learn how to assign names to these groups for more readable and maintainable code.

Learn about non-capturing groups as a way to group parts of a regex pattern for alternation or quantification without capturing the matched text. This helps keep your captured results clean and focused on only the data you need.

Discover the power of back-references for matching repeated text or ensuring that opening and closing tags are correctly paired. You will learn how to refer back to a previously captured group within the same regular expression.

Learn how to find all non-overlapping occurrences of a pattern in a string. This lecture compares re.findall(), which returns a list of strings, with re.finditer(), which returns a memory-efficient iterator of match objects.

Discover how to use re.split() to break a string apart based on a complex regex pattern, going beyond simple fixed delimiters. This is perfect for parsing data with inconsistent separators or whitespace.

Learn how to perform powerful search-and-replace operations using re.sub(). You'll see how to use back-references in the replacement string to reorder or reuse captured text.

This lecture covers how to deserialize, or parse, JSON data into Python objects. You will use json.load() and json.loads() to convert JSON from files and strings into Python dictionaries and lists.

Learn how to serialize Python objects, like dictionaries and lists, into JSON-formatted strings. You'll use json.dump() and json.dumps() to write JSON to files and strings, including how to pretty-print the output for human readability.

This lecture introduces YAML as a human-friendly data serialization format commonly used in DevOps tools like Kubernetes and Ansible. You will learn its basic syntax, which relies on indentation and allows for comments.

Learn how to work with YAML data in Python using the PyYAML library. You'll use yaml.safe_load() to parse YAML into Python objects and yaml.dump() to serialize Python objects back into YAML format.

This lecture covers how to read and parse data from Comma-Separated Values (CSV) files. You will learn to use csv.reader to get rows as lists and csv.DictReader to get them as dictionaries using the header row as keys.

Learn how to write data from Python into CSV files. You will use csv.writer to write lists as rows and csv.DictWriter to write dictionaries, including how to write the header row and handle missing data.

This lecture provides an overview of the different topics covered in this section.

Learn how to access environment variables in Python using the os module. This lecture covers the difference between the safe os.getenv() method and accessing the os.environ dictionary directly.

Discover how to modify environment variables from within your Python script. You'll learn how to set and delete variables at runtime, which can be useful for configuring child processes spawned by your script.

Learn how to use .env files to manage environment variables for local development. This lecture shows you how to use the python-dotenv library to automatically load key-value pairs from a file into your environment.

This lecture covers how to list the contents of a directory using both os.listdir and the more modern pathlib.Path.iterdir. You'll understand the key differences between the two approaches and when to use each.

Learn how to create directories from your Python script using both os.makedirs and pathlib.Path.mkdir. You'll discover how to create nested parent directories and how to avoid errors if the directory already exists.

This lecture covers how to safely delete files and directories. You'll learn to use os.remove for files, os.rmdir for empty directories, and the powerful shutil.rmtree for recursively deleting a directory and all its contents.

Discover how to copy files and directories using the shutil module. You'll learn the difference between shutil.copy and shutil.copy2 for files, and how to use shutil.copytree to recursively copy an entire directory.

Learn how to move or rename files and directories using the shutil.move function. This lecture explains how its behavior changes depending on whether the destination is a file or a directory.

This lecture introduces the tempfile module for creating secure temporary files with unique names. You'll learn how to use TemporaryFile and NamedTemporaryFile for scratch data that is automatically cleaned up.

Discover how to create a temporary directory and all its contents, which will be automatically removed when you're done. You'll learn how TemporaryDirectory is ideal for workflows that produce multiple temporary files.

This lecture introduces the subprocess module as the modern, secure way to run external commands from your Python scripts. You will learn the basic syntax of subprocess.run and how to pass arguments to a command.

Learn how to robustly handle errors that occur when running external commands. This lecture covers how to use check=True to automatically raise a CalledProcessError for non-zero exit codes, allowing you to catch and handle failures.

Discover how to prevent your scripts from hanging by setting a timeout on external commands. You'll learn how to catch the TimeoutExpired exception to gracefully handle processes that run for too long.

This lecture provides an overview of the different topics covered in this section.

This lecture goes through the process to create a GitHub PAT token so that later authentication lectures can be fully implemented.

This lecture introduces the powerful and user-friendly requests library for making HTTP requests. You'll learn how to perform a basic GET request to retrieve data and how to inspect the response object's status code and headers.

Discover how to pass query parameters in a GET request for tasks like filtering, sorting, and pagination. You'll learn to provide them as a dictionary, letting requests handle the URL encoding for you.

Learn how to send data to a server and create or update resources using POST requests. This lecture shows you how to pass a Python dictionary as a JSON payload, which requests will automatically serialize.

This lecture provides a deeper look at handling HTTP response status codes. You'll learn how to use the response.ok attribute for a quick success check and how to inspect response.status_code for more specific logic.

Discover a convenient way to automatically handle HTTP errors with the response.raise_for_status() method. This will raise an HTTPError exception for any 4xx or 5xx responses, promoting a fail-fast approach to error handling.

Learn how to implement Basic Authentication to access protected API endpoints. This lecture shows you how to pass a username and password tuple to the auth parameter of a request.

Discover the more common pattern of using token-based authentication for modern APIs. You'll learn how to pass an API key or a bearer token in the Authorization header to authenticate your requests.

Learn how to make your API clients more resilient by handling timeouts. This lecture explains how to set connection and read timeouts to prevent your script from hanging indefinitely on slow network responses.

Discover how to implement a simple retry mechanism to handle transient network errors or temporary server overloads. You'll learn how to wrap your request in a loop that retries a fixed number of times on failure.

Learn how to build a production-grade retry mechanism using exponential backoff. You'll also see how to add jitter (a small, random delay) to prevent "thundering herd" problems where many clients retry simultaneously.

This lecture provides an overview of the different topics covered in this section.

This lecture goes through my personal VS Code settings for the Pylance static typing checking extension in VS Code.

This lecture introduces type hints as a way to add optional static type checking to your Python code. You will learn the basic syntax for annotating variables, function parameters, and return values, leading to more readable and maintainable code.

Understand that type hints do not change Python's dynamic runtime behavior and are primarily for static analysis tools like mypy. This lecture highlights common pitfalls, such as believing hints enforce types at runtime, to ensure you have the right expectations.

Learn how to specify the type of elements contained within a list using built-in generics like list[str] or list[int]. This provides clearer and more precise type information than just annotating a variable as a list.

This lecture covers how to add type hints to other common collections. You'll learn to type dictionaries with key and value types (dict[str, int]), tuples with fixed or variable element types, and sets with a specific item type (set[str]).

Discover how to handle variables that can hold more than one type. You'll learn to use Union (or the | operator) for values that can be one of several types, and Optional for values that can be either a specific type or None.

Learn how to use TypedDict to define the precise structure of a dictionary, including its required keys and their corresponding types. This gives you much stronger static guarantees than the generic dict type, preventing common errors like typos in key names.

This lecture shows you how to add type hints to your own custom classes. You'll learn how to annotate class attributes and methods, making your class APIs clearer and enabling static checkers to verify their correct usage.

Discover how to handle situations where you need to reference a type that has not yet been defined, which is common in class methods that return an instance of themselves. You'll learn to use string-based forward references or from __future__ import annotations to solve this.

This lecture introduces TypeVar as a way to create generic functions and classes that can work with multiple data types. This powerful feature allows you to write flexible, reusable code while preserving the type relationship between inputs and outputs.

Learn how to create a type variable that is constrained to a specific set of types. This allows you to create generic functions that are flexible but still limited to types that support a certain set of operations (e.g., only int and float).

Discover how to create a type variable that accepts any subclass of a specific parent class. This is useful when you want to write a generic function that operates on objects sharing a common base class interface.

Learn how to create your own generic container types, similar to Python's built-in list or dict. By subclassing Generic, you can create classes that can be parameterized with a specific type, ensuring type safety for their contents.

This lecture covers the advanced topic of adding type hints to decorators. You'll learn how to use Callable and TypeVar to correctly type a decorator so that it preserves the signature of the function it wraps.

Dive deeper into typing decorators by using ParamSpec to perfectly capture and preserve the parameter signature of a decorated function. This modern approach provides the most accurate type information, eliminating the need for Any or type casting.

Learn how to add type hints to generator functions using the Generator type. You'll see how to specify the types for the yielded value, the value sent back into the generator, and the final return value.

Understand the distinction between Iterable and Iterator in the context of type hints. You'll learn why Iterable is the more common and flexible choice for function arguments that can accept any sequence, including lists, tuples, and generators.