Only Few Seats Left

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 Environments

·       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.