Python for Automation, AI Applications & LLM Integration

Python for Automation, AI Applications & LLM Integration
(In Association with iHUB Divyasampark IIT Roorkee)

About the Course:

Course Objectives:

• Build a strong foundation in Python programming by working with core syntax, data types, control flow, strings, data structures, comprehensions, and data processing techniques.
• Develop modular, reusable, and object-oriented Python applications using functions, modules, packages, functional programming, OOP principles such as inheritance, polymorphism, abstraction, and properties.
• Apply advanced Python programming techniques including decorators, lambda and higher-order functions, dunder methods, custom exceptions, and other advanced language features to develop robust applications.
• Automate real-world tasks using Python through file and directory management, data processing, command-line utilities, regular expressions, and practical automation workflows.
• Develop and manage professional Python projects using third-party libraries, pip, virtual environments, dependency management, APIs, HTTP requests, JSON data processing, multithreading, and multiprocessing.
• Adopt professional software development and collaboration practices using Git and GitHub/GitLab for version control, branching, merging, conflict resolution, remote collaboration, and pull requests.
• Leverage AI-assisted Python development tools and LLM APIs such as ChatGPT, GitHub Copilot, Cursor AI, and OpenAI APIs for code generation, debugging, code explanation, problem-solving, and integrating AI capabilities into Python applications.
• Apply the acquired skills to develop industry-oriented Python solutions and a capstone project, including an AI-powered virtual assistant integrating Python with OpenAI and application interfaces.
   

Prerequisites and eligibility:

Course Overview:

Module 1: Python Fundamentals & Data Structures

• Introduction to Python: Applications, installation, development environments, syntax, indentation and comments
• Variables & Data Types: Variables, constants, numbers, strings, Boolean values, type conversion and type checking
• Operators & Expressions: Arithmetic, relational, logical, assignment and other operators; expressions
• Input & Output: User input, formatted output and basic input/output operations
• Control Flow & Loops: if, elif, else, nested conditions, for and while loops, break, continue and pass
• Strings: String creation, indexing, slicing, methods and common string operations 
• Lists & Tuples: List creation and methods, tuple creation and operations, indexing, slicing and nested sequences
• Sets & Dictionaries: Set creation and operations; dictionaries, dictionary methods, nested data structures
• Comprehensions & Iteration: List, set and dictionary comprehensions; iterating over Python data structures
• Data Processing Operations: Sorting, searching and practical manipulation of Python data structures
• Important Object Concepts: Mutable vs. immutable objects and their practical implications
• Hands-on: Basic Programming Problems & Data processing using Python
  .·

Module 2: Functions, Modular Programming & Object-Oriented Programming

• Functions: Defining and calling functions, arguments and return values, positional and keyword arguments, default and variable-length arguments, *args and **kwargs
• Functional Programming: Lambda functions, map(), filter(), reduce() and recursion
• Variable Scope: Local, global and nonlocal variables; scope and lifetime of variables
• Modules & Packages: Importing modules, creating user-defined modules, packages and package structures, Python standard library
• Introduction to OOP: Object-oriented programming concepts, classes, objects, attributes, methods, constructors and destructors
• Methods & Encapsulation: Instance, class and static methods; encapsulation, properties and decorators
• Inheritance: Inheritance concepts and types of inheritance; method overriding
• Polymorphism & Abstraction: Polymorphism, abstract classes and interfaces
• Hands-on: Developing a Modular Object-Oriented Python Application

Module 3: Advanced Python Programming

• Advanced Functions & Decorators: Function decorators, wrapper functions, nested functions, decorators with arguments, decorator syntax and practical use cases such as logging, timing, authentication, caching and rate limiting
• OOP-Advanced Concepts: Getters and setters, @property, property setters, encapsulation and creating computed properties
• Methods in Python Classes: Instance methods, static methods using @staticmethod, class methods using @classmethod, class attributes and instance attributes
• Magic/Dunder Methods: Double-underscore methods, __init__, __str__, __repr__, __len__ and customizing object behavior through special methods
• Exception Handling: Handling errors using try, except, else and finally; handling specific exceptions, accessing exception information and raising custom exceptions with raise
• Functional Programming: Higher-order functions, map(), filter(), reduce() and applying functions to Iterables
• Lambda Functions: Creating anonymous functions and using lambda expressions with map(), filter() and other functional programming patterns
• Walrus Operator: Assignment expressions using :=; assigning and using values within expressions, reducing repeated calculations and simplifying loops and conditional expressions
• Hands-on Project: Advanced Python Automation using Decorators, OOP, Functional Programming and Exception Handling

Module 4:  File Handling, Data Processing & Automation

• File I/O & File Operations: Reading, writing and appending files; file modes, line-by-line file processing, file pointers, read()/write() operations and context managers using with statement.
• File & Directory Management: Listing, checking, copying, moving and deleting files and directories using os and shutil
• File & Directory Automation: Automating file and directory management tasks, including organizing files by type and working with nested directories
• Command-Line Utilities: Creating command-line tools using Python's argparse module; command-line arguments, argument types, help messages, choices and argument parsing
• Command-Line Automation: Building Python scripts that accept user inputs and perform operations directly from the terminal
• Error Handling in File Operations: Handling missing files, invalid paths and file-related errors using exceptions and try-except
• Hands-on Project: Automated File Management / Command-Line Utility

Module 5:  Python Libraries, Packages, APIs & Virtual Environment

• Python Libraries & Modules: Python Standard Library, built-in modules, importing modules and packages, external/third-party libraries, package documentation and module usage.
• Package Management: Installing, upgrading, uninstalling and managing third-party packages using pip; checking installed packages with pip list; installing specific package versions.
• Virtual Environments: Creating, activating and deactivating isolated Python environments; managing project-specific dependencies and package versions.
• Dependency Management: Generating and using requirements.txt; freezing package versions with pip freeze; installing project dependencies with pip install -r
• APIs & HTTP Requests: Using the requests library to make GET and POST requests, retrieving data from URLs, sending request data and working with different HTTP request methods
• API Data Processing: Processing text and JSON responses from external APIs and saving API responses to files
• Regular Expressions: Pattern matching and text processing using Python's re module; searching, finding multiple matches, case-insensitive matching and replacing patterns
• Multithreading & Parallel Execution: Thread-based parallel execution for I/O-bound tasks; creating and starting threads, passing arguments, using join() and understanding the Global Interpreter Lock (GIL)
• Multiprocessing: Introduction to multiprocessing for CPU-bound tasks and understanding when multiprocessing is preferred over multithreading
• Hands-on Project: Developing a Reusable API Integration Tool with Dependency Management, Regular Expression Processing and Parallel Execution

Module 6: Version Control: Git for Developers

• Git Fundamentals: Version control concepts, Git workflow, repositories, installation and configuration
• Repository Management: Creating and cloning repositories, .gitignore, repository structure and remote repositories
• Tracking & Managing Changes: Working directory, staging area, commits, git status, git add, git diff and commit history
• Branching & Merging: Creating and managing branches, merging, resolving merge conflicts and basic branching strategies
• Remote Collaboration: GitHub/GitLab, push, pull, fetch, pull requests and collaborative development
• Undoing & Recovering Changes: restore, reset, revert, stash, tags and version recovery
• Hands-on: Managing and Collaborating on a Python Project using Git & GitHub

Module 7: AI-assisted Python Development & Capstone Project

• AI-Assisted Python Development: When and how to use AI tools effectively for Python programming, debugging, code explanation and problem-solving
• AI Coding Assistants: Practical use of ChatGPT, GitHub Copilot, Cursor AI and other AI-powered coding assistants for Python development
• Working with LLM APIs: Introduction to LLM APIs, API requests, authentication, prompts, response handling and integrating LLM capabilities into Python applications
• Capstone Project: Build an AI-powered virtual assistant using Python and OpenAI. Create a chatbot with an API key, chat completions, and web or mobile app integrations.

Contact Person: Dr. Subrat Kotoky

Email: [email protected] / [email protected]

Phone: 9085317465 / 8473874389

Expert Profile: Mr. Shreyas Shukla

       


Register Now