Skip to content

README.md

Latest commit

 

History

History
140 lines (120 loc) · 9.16 KB

README.md

File metadata and controls

140 lines (120 loc) · 9.16 KB

Python Daily Practice

A structured repository dedicated to tracking my daily progress in Python programming, focusing on automation, logic building, and efficient scripting.

📂 Directory Structure

For better maintainability and clear progression tracking, the repository is organized into day-wise modules:

📁 Day_01_and_02_Basics

Core Fundamentals & Conditional Logic

  • Variables & Data Types: Understanding how to store and manipulate data.
  • Input/Output (I/O): Interactive scripting using input() and formatted print().
  • Arithmetic Operations: Basic mathematical computations and logic.
  • Conditionals: Implementing decision-making using if-elif-else statements (e.g., Voting Eligibility, Traffic Light Bot).

📁 Day_03_For_Loops

Iteration & Mathematical Algorithms

  • Loops & Iteration: Mastering for loops for repetitive tasks and sequence traversal.
  • Math Logic: Implementing classic algorithms such as Factorial calculation, Square numbers, and Multiples.
  • Sequence Manipulation: String iteration and reverse counting.
  • Pattern Generation: Visualizing logic through nested structures (e.g., Star patterns).

📁 Day_04_While_Loops

Conditional Iteration & Control Flow

  • Basic While Loops: Implementing condition-based iteration.
  • Sentinel Values: Using specific inputs to terminate loops dynamically.
  • Control Statements: Mastering break for early exit and continue for skipping iterations.
  • Loop Else Block: Understanding the while...else structure unique to Python.
  • Logic Building: Applying while loops to math (Factorials) and simple logic games.

📁 Day_05_Functions

Modular Programming & Scope ✅ COMPLETED

  • Function Basics: Defining and calling reusable blocks of code.
  • Arguments & Parameters: Mastering positional, keyword, and default arguments.
  • Return Values: Handling single and multiple outputs (tuples) from functions.
  • Variable Scope: Understanding Local vs Global namespaces.
  • Advanced Concepts: Anonymous (Lambda) functions and variable-length arguments (*args, **kwargs).
  • Logic Modules: Building function-driven tools like calculators and string processors.

📁 Day_06_Data_Structures

Advanced Sequences & Mappings ✅ COMPLETED

  • Lists & Mutability: mastering dynamic arrays and sequence slicing.
  • Tuples & Sets: Understanding immutability and mathematical set operations (union/intersection).
  • Dictionaries: Deep dive into key-value pairs and nested structures.
  • Comprehensions: Writing "Pythonic" code with list and dictionary comprehensions.
  • Practical Data: Implementing Stacks, Queues, and mock AI datasets.

📁 Day_07_Functions_and_Errors

Modular Programming, File I/O & Robust Logic ✅ COMPLETED

  • Advanced Functions: Deep dive into *args, **kwargs, and nested functions.
  • Anonymous Logic: Mastering lambda, map(), and filter().
  • Scope Management: Handling Local vs Global variables using the global keyword.
  • Error Handling: Implementing try-except-else-finally blocks and custom exceptions.
  • File I/O: Practical application of reading, writing, and appending to .txt files.
  • Robust Systems: Building fault-tolerant calculators and mock data cleaners.

📁 Day_08_OOP_Basics

Object-Oriented Programming (OOP) Fundamentals ✅ COMPLETED

  • Classes & Objects: Defining blueprints and instantiating objects.
  • Constructors: Using __init__ for attribute initialization.
  • Methods: Implementing instance methods to manipulate object data.
  • Variable Scope: Understanding Class variables vs Instance variables.
  • Inheritance & Polymorphism: Creating parent/child relationships and method overriding.
  • Encapsulation: Data hiding using private attributes and getter/setter methods.
  • Practical OOP: Building models for Gaming, Networking, and YouTube management.

📁 Day_09_Advanced_OOP

Advanced Object-Oriented Programming ✅ COMPLETED

  • Magic Methods (Dunder): Mastering __str__, __repr__, __add__, and __eq__ for custom object behavior.
  • Class Methods: Using @classmethod for alternative constructors and class-level logic.
  • Static Methods: Implementing @staticmethod for utility functions that don't require instance state.
  • Property Decorators: Using @property for managed attribute access (Getters, Setters, Deleters).
  • Custom Exceptions: Designing user-defined error classes for robust error handling.
  • Abstract Base Classes (ABC): Enforcing method implementation in child classes using the abc module.
  • Complex Models: Building advanced systems for Inventory Management, YouTube Analytics, and Network Data Packets.

📁 Day_10_File_and_OS_Operations

File Handling, OS Module & Data Serialization ✅ COMPLETED

  • File I/O Basics: Mastering open(), read(), write(), and append() modes.
  • Context Managers: Implementing safe file operations using the with statement.
  • OS Module: Navigating directories, listing files, and path management.
  • Data Formats: Parsing and generating CSV and JSON data for configuration and storage.
  • System Utilities: Using shutil for backups and sys.argv for CLI tool development.
  • Practical Tools: Building game save managers, log archivers, and metadata extractors.

📁 Day_11_OOP_Fundamentals

Object-Oriented Programming (OOP) Fundamentals ✅ COMPLETED

  • Classes & Objects: Defining blueprints, instantiating objects, and understanding self.
  • Constructors: Using __init__ for attribute initialization.
  • Variable Scope: Mastering Class variables vs Instance variables.
  • Inheritance: Creating parent/child relationships and using super().
  • Polymorphism: Method overriding and unified interfaces.
  • Encapsulation: Data protection using private attributes (_ and __).
  • Magic Methods: Implementing dunder methods like __str__ and __len__.
  • Practical OOP: Building models for Team Management, PC Building, and YouTube Metadata.

📁 Day_12_Advanced_OOP

Advanced Object-Oriented Programming ✅ COMPLETED

  • Class & Static Methods: Mastering @classmethod and @staticmethod for versatile class design.
  • Property Decorators: Implementing managed attribute access with Getters, Setters, and Deleters.
  • Abstract Base Classes: Enforcing structural contracts in subclasses using the abc module.
  • Multiple Inheritance: Understanding MRO (Method Resolution Order) and multi-parent hierarchies.
  • Custom Exceptions: Designing domain-specific error classes for robust OOP applications.
  • Dataclasses: Leveraging @dataclass for concise and efficient data modeling.
  • Operator Overloading: Implementing dunder methods for custom mathematical object behavior.
  • Design Patterns: Implementing the Singleton pattern for centralized state management.
  • Object Serialization: Using pickle to save and restore complex class instances.

📁 Day_13_Scraping_and_APIs

Web Scraping, API Integration & Data Automation ✅ COMPLETED

  • HTTP Requests: Mastering GET and POST methods using the requests library.
  • HTML Parsing: Using BeautifulSoup to navigate and extract data from DOM structures.
  • CSS Selectors: Implementing advanced .select() queries for precise data extraction.
  • REST APIs: Fetching and parsing JSON data from live endpoints (e.g., PokeAPI).
  • Data Serialization: Automating mock data generation and exporting to JSON and CSV formats.
  • Browser Automation: Basic setup and interaction using Selenium for dynamic web tasks.
  • Robust Scraping: Implementing error handling, timeouts, and status code verification.

📁 Day_14_Gemini_CLI_Suite

Gemini AI Integration & CLI Automation ✅ COMPLETED

  • Gemini SDK: Mastering connectivity with google-generativeai using gemini-2.5-flash and gemini-2.5-pro.
  • CLI Tooling: Building command-line utilities for code explanation and image analysis.
  • Automated Documentation: Generating dynamic Markdown documentation from source code metadata.
  • Structured Data: Extracting precise JSON objects from unstructured text using Gemini's JSON mode.
  • System Instructions: Configuring specialized AI agents with strict personas (e.g., Security Auditor).
  • Token Management: Implementing token counting and cost estimation utilities.
  • Resilient Logic: Building robust API interaction layers with exponential backoff and error handling.
  • Conversation Logging: Designing persistent chat loops with automated history serialization.

🚀 How to Run

Navigate to the specific day's directory and execute the script using Python 3:

cd Day_01_and_02_Basics
python 01_hello_world.py

🔒 License

This repository is for educational purposes. Feel free to explore and use the scripts for learning.