Skip to content

15_Day_Python_Mastery.md

Latest commit

 

History

History
569 lines (470 loc) · 20.6 KB

15_Day_Python_Mastery.md

File metadata and controls

569 lines (470 loc) · 20.6 KB
Raw

🐍 15-Day Python Mastery: From Zero to Hero

Python License PRs Welcome

📚 About This Repository

Welcome to 15-Day Python Mastery – a comprehensive, hands-on Python course designed to transform complete beginners into proficient Python programmers in just 15 days! This repository contains carefully structured learning materials, including Jupyter notebooks with practical code examples, detailed markdown notes, YouTube video tutorials, and Google Colab links for hands-on practice.

Whether you're a complete non-coder or someone looking to solidify their Python fundamentals, this course provides a clear, step-by-step path to Python mastery with 16 days of content (Day 0 for setup + 15 days of core learning).

📊 Course Overview - Quick Navigation

Day Topic Focus Area Key Concepts
Day 0 Getting Started 🚀 Environment Setup Python Installation, VS Code, Virtual Environments (UV, venv, Miniconda)
Day 1 Python Basics & Syntax 📖 Foundation Variables, Data Types, I/O, Basic Operators, First Program
Day 2 Strings & String Manipulation 🔤 Text Processing String Methods, Slicing, Formatting, Validation
Day 3 Control Flow - Conditionals 🔀 Decision Making if-else, elif, Ternary, match/case, Boolean Logic
Day 4 Control Flow - Loops 🔁 Iteration for, while, enumerate, zip, Loop Patterns + Mini-Project
Day 5 Lists & Tuples 📋 Sequential Data List/Tuple Methods, Slicing, Comprehensions, Identity/Membership
Day 6 Dictionaries & Sets 🗂️ Collections Dict/Set Operations, All Comprehensions + Mini-Project
Day 7 Functions - Basics 🔧 Code Reusability Parameters, Arguments, Return, Scope, Docstrings
Day 8 Functions - Advanced 🚀 Advanced Functions Lambda, Map/Filter, Recursion, Closures, Higher-Order
Day 9 Modules & Packages 📦 Code Organization Imports, Iterators, Generators, Standard Library + Mini-Project
Day 10 Exception Handling ⚠️ Error Management try-except, Custom Exceptions, Context Managers, Debugging
Day 11 File Handling 📁 File Operations Read/Write, CSV, JSON, Regex, pathlib + Mini-Project
Day 12 OOP - Basics 🏗️ Classes & Objects Classes, Methods, Encapsulation, Properties, Static/Class Methods
Day 13 OOP - Advanced 🎓 Inheritance & Decorators Inheritance, MRO, Polymorphism, Decorators, Magic Methods + Mini-Project
Day 14 Working with Data & Time 🕐 Essential Modules datetime, collections, Additional Operators, Standard Library
Day 15 Testing, Best Practices & Projects 🏆 Professional Dev PEP 8, Testing, Debugging, Capstone Projects, Next Steps

💡 Tip: Click on any day to jump directly to that folder and start learning!

🎯 Learning Objectives

By the end of this 15-day journey, you will:

  • ✅ Understand Python fundamentals from scratch
  • ✅ Write clean, efficient, and Pythonic code
  • ✅ Master data structures, functions, and OOP concepts
  • ✅ Handle files, exceptions, and work with modules
  • ✅ Work with popular Python libraries and frameworks
  • ✅ Build real-world projects and applications
  • ✅ Debug and test your code professionally
  • ✅ Be ready to tackle advanced Python topics and frameworks

📂 Repository Structure

This repository is organized into 16 daily folders (Day 0 to Day 15), each focusing on specific topics. Every day's folder follows a consistent structure:

15-Day-Python-Mastery/
│
├── Day_0_Getting_Started/
│   ├── 01_Installing_Python.md
│   ├── 02_Installing_VSCode.md
│   ├── 03_Environment_Setup_Overview.md
│   ├── 04_Virtual_Environment_UV.ipynb
│   ├── 05_Virtual_Environment_venv.ipynb
│   └── 06_Virtual_Environment_Miniconda.ipynb
│
├── Day_1_Python_Basics/
│   ├── notebook.ipynb          # Hands-on code examples
│   └── notes.md                # Detailed explanations and theory
│
├── Day_2_[Topic_Name]/
│   ├── notebook.ipynb
│   └── notes.md
│
└── ... (continues through Day 15)

📝 File Structure Explanation

  • notebook.ipynb: Interactive Jupyter notebook containing:

    • Code examples and demonstrations
    • Hands-on exercises
    • Practice problems
    • Output examples
    • Can be opened directly in Google Colab (link provided in notes.md)

  • notes.md: Comprehensive markdown file containing:

    • YouTube video tutorial - Watch the complete lesson
    • Google Colab link - Open the notebook directly in your browser
    • Theoretical explanations
    • Concept breakdowns
    • Command references
    • Best practices and tips
    • Additional resources

📅 15-Day Syllabus

Day 0: Getting Started 🚀

Focus: Environment Setup & Installation

Topics Covered:

  • Installing Python (Windows, macOS, Linux)
  • Installing and configuring VS Code
  • Understanding IDEs and text editors
  • Virtual environment concepts
  • Creating virtual environments with:
    • UV (modern, fast package installer)
    • venv (Python's built-in solution)
    • Miniconda (conda-based environment)
  • Installing packages with pip
  • Setting up your first Python project

Day 1: Python Basics & Syntax 📖

Focus: Foundation of Python Programming

Topics Covered:

  • Python syntax and indentation
  • Comments (single-line and multi-line)
  • Variables and naming conventions
  • Data types: int, float, string, boolean
  • Type conversion and type checking
  • Basic input/output operations
  • Print formatting and f-strings
  • Basic arithmetic operators (+, -, *, /, //, %, **)
  • Comparison operators (==, !=, <, >, <=, >=)
  • Logical operators (and, or, not)
  • Your first Python program

Day 2: Strings & String Manipulation 🔤

Focus: Mastering Text Processing

Topics Covered:

  • String creation and concatenation
  • String indexing and slicing
  • String methods (upper, lower, strip, split, join, replace, find, count, startswith, endswith)
  • String formatting (f-strings, .format(), %-formatting)
  • Escape characters and raw strings
  • Multi-line strings and docstrings
  • String immutability
  • Common string operations and patterns
  • Working with user input and validation
  • Practical string manipulation exercises

Day 3: Control Flow - Conditionals 🔀

Focus: Decision Making in Python

Topics Covered:

  • if statements
  • if-else statements
  • if-elif-else chains
  • Nested conditionals
  • Ternary operators (conditional expressions)
  • Boolean logic in conditions
  • Truthy and Falsy values in Python
  • Short-circuit evaluation
  • match/case statements (Python 3.10+)
  • Practical examples and use cases

Day 4: Control Flow - Loops 🔁

Focus: Iteration and Repetition

Topics Covered:

  • for loops
  • while loops
  • range() function
  • enumerate() function
  • zip() function
  • break and continue statements
  • pass statement
  • Nested loops
  • Loop else clause
  • Iterating over sequences
  • Loop patterns and best practices
  • Mini-project: Build a simple calculator or number guessing game

Day 5: Data Structures - Lists & Tuples 📋

Focus: Sequential Data Structures

Topics Covered:

  • Creating and accessing lists
  • List methods (append, extend, insert, remove, pop, sort, reverse, etc.)
  • List slicing and indexing (advanced techniques)
  • List comprehensions
  • Nested lists and 2D lists
  • Tuples and their immutability
  • Tuple packing and unpacking
  • Identity operators (is, is not) - with practical examples
  • Membership operators (in, not in)
  • Shallow vs deep copy (introduction)
  • When to use lists vs tuples
  • Common list operations and patterns

Day 6: Data Structures - Dictionaries & Sets 🗂️

Focus: Key-Value Pairs and Unique Collections

Topics Covered:

  • Creating and accessing dictionaries
  • Dictionary methods (keys, values, items, get, update, pop, setdefault, etc.)
  • Nested dictionaries
  • Sets and set operations
  • Set methods (add, remove, union, intersection, difference, symmetric_difference)
  • Frozen sets
  • When to use dictionaries vs sets
  • Comprehensions Deep Dive:
    • List comprehensions (review)
    • Dictionary comprehensions
    • Set comprehensions
    • Nested comprehensions
    • Comprehensions with conditionals
    • When to use comprehensions vs loops
  • Practical applications and exercises
  • Mini-project: Build a contact book or student grade manager

Day 7: Functions - Basics 🔧

Focus: Code Reusability and Organization

Topics Covered:

  • Defining functions
  • Function parameters and arguments
  • Return statements
  • Default parameters
  • Keyword arguments
  • *args and **kwargs
  • Variable scope (local, global, nonlocal)
  • Docstrings and documentation
  • Function best practices

Day 8: Functions - Advanced 🚀

Focus: Advanced Function Concepts

Topics Covered:

  • Lambda functions (anonymous functions)
  • Map, filter, and reduce functions
  • Recursion and recursive functions (factorial, fibonacci, tree traversal)
  • Closures and nested functions
  • Higher-order functions
  • Partial functions (functools.partial)
  • Function annotations and type hints (introduction)
  • Advanced Topics (brief introduction):
    • Decorators basics (will cover in-depth in Day 13)
    • Generators and yield (will cover in-depth in Day 9)
  • Practical function patterns and real-world examples

Day 9: Modules & Packages 📦

Focus: Code Organization and Reusability

Topics Covered:

  • Importing modules (import, from...import, import...as)
  • Creating custom modules
  • Understanding name and main
  • Packages and init.py
  • Iterators and Iterables:
    • Understanding iteration protocol
    • iter() and next() functions
    • Creating custom iterators
    • Difference between iterables and iterators
  • Generators (in-depth):
    • Generator functions with yield
    • Generator expressions
    • Benefits of generators (memory efficiency)
    • When to use generators vs lists
  • Standard library overview (math, random, datetime basics)
  • Popular third-party packages
  • Virtual environments in real projects
  • Module search path
  • Best practices for project structure
  • Mini-project: Create a custom module/package

Day 10: Exception Handling ⚠️

Focus: Error Management and Debugging

Topics Covered:

  • Understanding exceptions and errors
  • try-except blocks
  • Multiple except clauses
  • else and finally clauses
  • Raising exceptions (raise statement)
  • Custom exceptions
  • Common built-in exceptions (ValueError, TypeError, KeyError, etc.)
  • Exception hierarchy
  • Exception chaining
  • assert statements
  • Context managers and the with statement
  • Debugging techniques (print debugging, using debugger)
  • Best practices for error handling

Day 11: File Handling 📁

Focus: Reading and Writing Files

Topics Covered:

  • Opening and closing files
  • Reading files (read, readline, readlines)
  • Writing to files
  • File modes (r, w, a, r+, w+, etc.)
  • Using context managers with files (with statement)
  • Working with CSV files (csv module)
  • Working with JSON files (json module)
  • File paths and pathlib module
  • os and sys modules (directory operations, environment variables)
  • Exception handling with files (applying Day 10 knowledge)
  • Regular Expressions (Regex):
    • Introduction to regex patterns
    • re module (match, search, findall, sub)
    • Common regex patterns
    • Practical use cases (email validation, text extraction)
  • Mini-project: Build a log file analyzer or text processor

Day 12: Object-Oriented Programming - Basics 🏗️

Focus: Classes and Objects

Topics Covered:

  • Introduction to OOP concepts
  • Classes and objects
  • init method (constructor)
  • Instance variables and methods
  • Class variables and methods
  • self parameter explained
  • @staticmethod and @classmethod decorators
  • Encapsulation principles
  • Public, protected, and private attributes (naming conventions)
  • Property decorators (@property, @setter, @deleter)
  • str and repr methods
  • Object identity and equality (eq, hash)
  • Practical OOP examples

Day 13: Object-Oriented Programming - Advanced 🎓

Focus: Inheritance, Polymorphism & Decorators

Topics Covered:

  • Inheritance basics (single inheritance)
  • Method overriding
  • super() function and its usage
  • Multiple inheritance
  • Method Resolution Order (MRO)
  • Polymorphism and duck typing
  • Abstract classes and methods (ABC module)
  • Composition vs inheritance
  • Decorators (In-Depth):
    • Understanding decorators
    • Function decorators
    • Class decorators
    • Decorators with arguments
    • Built-in decorators (@property, @staticmethod, @classmethod)
    • Creating custom decorators
  • Magic/dunder methods (len, getitem, setitem, call, etc.)
  • OOP design principles (SOLID basics)
  • Mini-project: Build a class-based application (e.g., Library Management, Bank Account)

Day 14: Working with Data & Time 🕐

Focus: Essential Python Modules for Real-World Applications

Topics Covered:

  • datetime module:
    • Working with dates and times
    • datetime, date, time, timedelta objects
    • Formatting dates (strftime, strptime)
    • Time zones (brief introduction)
    • Calculating time differences
  • collections module:
    • defaultdict
    • Counter
    • namedtuple
    • deque
    • OrderedDict
  • Additional Operators & Concepts:
    • Assignment operators (=, +=, -=, *=, /=, //=, %=, **=)
    • Bitwise operators (brief overview: &, |, ^, ~, <<, >>)
    • Operator precedence (comprehensive)
    • Walrus operator := (Python 3.8+)
  • Useful Standard Library Modules:
    • random module (random numbers, choices, shuffle)
    • math module (mathematical functions)
    • statistics module (mean, median, mode)
  • Practical exercises and real-world examples

Day 15: Testing, Best Practices & Projects 🏆

Focus: Professional Python Development

Topics Covered:

Part 1: Testing & Best Practices

  • PEP 8 style guide and code formatting
  • Writing clean, readable, and maintainable code
  • Code organization and project structure
  • Documentation best practices (docstrings, comments)
  • Testing Basics:
    • Introduction to testing
    • unittest module basics
    • pytest basics (if time permits)
    • Writing simple test cases
    • Test-driven development (TDD) introduction
  • Debugging & Tools:
    • Debugging techniques
    • Using print statements effectively
    • Python debugger (pdb) introduction
    • Code linting (pylint, flake8)
  • Type hints and annotations (introduction)
  • Virtual environments in production
  • Version control with Git (brief overview)

Part 2: Capstone Projects

  • Project planning and requirements
  • Applying all learned concepts (Days 0-14)
  • Building 2-3 complete applications:
    • CLI-based application (e.g., Task Manager, Quiz App)
    • Data processing application (e.g., CSV analyzer, Text processor)
    • OOP-based application (e.g., Library Management, Banking System)
  • Code review and optimization
  • Best practices in action
  • Next Steps:
    • Web development (Django, Flask)
    • Data Science (NumPy, Pandas - your next course!)
    • Automation and scripting
    • APIs and web scraping
    • Resources for continued learning

Note: This day includes a comprehensive project repository with multiple real-world Python projects. Check out the Python Projects Repository for detailed project implementations, code walkthroughs, and step-by-step guides.

🚀 How to Use This Repository

Prerequisites

  • A computer (Windows, macOS, or Linux)
  • Internet connection
  • Enthusiasm to learn!

Getting Started

  1. Clone this repository:

    git clone https://github.com/yourusername/15-Day-Python-Mastery.git
cd 15-Day-Python-Mastery

  2. Start with Day 0: Follow the installation guides to set up your environment

  3. Daily Learning Routine:

    • Open the notes.md file for the day
    • Watch the YouTube video tutorial (link in notes.md) - Learn by watching
    • Open the notebook in Google Colab (link in notes.md) or locally in Jupyter/VS Code
    • Code along with the video tutorial
    • Run the code examples and experiment
    • Complete the exercises
    • Review the theoretical explanations in notes.md
    • Build your own examples

  4. Practice, Practice, Practice: The key to mastery is consistent practice!

Recommended Study Schedule

  • Time Commitment: 2-4 hours per day
  • Approach:
    • 20% watching video tutorials
    • 30% reading theory (notes.md)
    • 40% hands-on coding (notebook.ipynb + Google Colab)
    • 10% experimentation and exercises

💡 Tips for Success

  1. Watch First, Code Second: Watch the YouTube tutorial, then code along
  2. Use Google Colab: No setup required - start coding immediately in your browser
  3. Don't Rush: Take your time to understand each concept
  4. Code Along: Type the code yourself, don't just watch or read
  5. Experiment: Modify examples and see what happens
  6. Debug: When errors occur, try to understand why
  7. Build Projects: Apply what you learn to small projects
  8. Ask Questions: Use Stack Overflow, Python forums, or GitHub discussions
  9. Review: Revisit previous days' content and videos regularly
  10. Stay Consistent: Daily practice is better than cramming

🤝 Contributing

Contributions are welcome! If you find errors, have suggestions, or want to add content:

  1. Fork the repository
  2. Create a new branch (git checkout -b feature/improvement)
  3. Make your changes
  4. Commit your changes (git commit -am 'Add new feature')
  5. Push to the branch (git push origin feature/improvement)
  6. Create a Pull Request

📜 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

  • Python Software Foundation
  • The amazing Python community
  • All contributors to this project

📞 Contact & Support

If you have questions or need help:

  • Open an issue in this repository
  • Star ⭐ this repo if you find it helpful!
  • Share it with others who want to learn Python

Happy Coding! 🐍✨

Remember: Every expert was once a beginner. Your journey to Python mastery starts now!

📋 Syllabus Improvements Summary

This curriculum has been professionally reviewed and enhanced with the following improvements:

✅ Critical Additions:

  1. Day 2: Dedicated String Manipulation - Essential for beginners (30-40% of coding tasks)
  2. Iterators & Generators - Added to Day 9 (foundational concepts)
  3. Regular Expressions (Regex) - Added to Day 11 (text processing essential)
  4. datetime & collections modules - Added to Day 14 (real-world applications)
  5. Mini-Projects - Added throughout (Days 4, 6, 9, 11, 13) for hands-on practice

🔄 Strategic Reorganizations:

  1. Basic operators moved to Day 1 - Immediate practical use
  2. Exception Handling before File Handling (Days 10-11 swapped) - Proper error handling foundation
  3. Decorators moved to Day 13 - Makes more sense after OOP
  4. Generators moved to Day 9 - With iterators for better flow
  5. Testing & Projects combined in Day 15 - Comprehensive finale

🎯 Enhanced Coverage:

  • Added enumerate(), zip() to loops
  • Added identity/membership operators with data structures
  • Consolidated all comprehensions in Day 6
  • Added @staticmethod, @classmethod to OOP basics
  • Added pathlib, collections, and additional operators
  • Included match/case statements (Python 3.10+)
  • Added practical debugging techniques

📚 Pedagogical Improvements:

  • Better progression from simple to complex
  • Topics grouped logically
  • Mini-projects for reinforcement
  • All advanced topics kept but organized better
  • Clear preparation for Data Science track (NumPy, Pandas next!)

Result: A comprehensive, well-structured, industry-relevant Python curriculum that takes complete beginners to job-ready Python developers in 15 days! 🚀