Mastering OOP in Python: My 100-Day Learning Journey

Sometimes, the best way to move forward… is to go back to the basics. 🐍 Over the last few days, I spent time revisiting Python — not by just watching videos or reading notes, but by actually writing code, making mistakes, fixing them, and understanding why things work. I practiced and built small programs around: ✅ Functions ✅ Lists, dictionaries, and sets ✅ File handling ✅ Error handling ✅ OOP concepts ✅ Inheritance ✅ @property and magic methods ✅ Working with files and folders using the os module And honestly, this kind of practice hits differently. Every small bug I fixed taught me something. Every concept I struggled with made more sense after writing code around it. One thing this reminded me of: 👉 Good engineers are built on strong basics. No shortcuts. Just consistency, curiosity, and hands-on practice. I’ve uploaded all my Python practice programs here: 🔗 GitHub Repo: https://lnkd.in/gGUPgkWU Still learning. Still building. And enjoying the process. 🚀 If you’re also going back to the basics right now — you’re not starting over. You’re building stronger this time. #Python #LearningInPublic #PythonProgramming #GitHub #CodingJourney #SoftwareEngineering #DeveloperLife #100DaysOfCode

I didn’t just “learn Python” — I forced myself to prove it by working tougher over the past few weeks Instead of jumping from one tutorial to another, I sat down and actually built things. No shortcuts, no skipping — just writing code, breaking it, fixing it, and repeating. So I turned everything into a structured repository: notes + concepts + working programs + mini projects. 📚 What this included: • Core fundamentals (variables, strings, numbers) • Control flow (if-else, operators, logic building) • Loops and iteration (including nested logic) • Functions and arguments • How Python actually runs (interpreter → bytecode → execution) 💻 What I ended up building: • 🔢 A menu-driven calculator • 💰 An interest + tax calculation system • 🔐 A password strength checker • 🎯 A number guessing game • 🎓 A full CLI-based student management system (CRUD) The interesting part? At the start, even small logic felt confusing. By the end, I was comfortably structuring full programs. Not because I “finished a course” — but because I kept writing code until things started making sense. 🔗 Here’s everything I built: [ https://lnkd.in/grknB8p6 ] This is just the beginning. Next step: build something bigger and less comfortable. #Python #Programming #BuildInPublic #CodingJourney #StudentDeveloper #GitHub #LearnToCode #SoftwareDevelopment

Following are some of the important features of Python: ============================================= -Python is open source: -Python is interpreted: -Python is cross platform compatible: -Python is Object-Oriented: -Python is a great choice for new learners: -Python is extensible: -Python is interactive:  -Database connectivity: Git Hub Location: https://lnkd.in/gSbydkPG

🚀 New Python Project: To-Do List Application I built a simple To-Do List application using Python to practice working with user input, lists, and basic program logic. This project allows users to manage their daily tasks directly from the terminal. 📌 Key Features • Add new tasks • View all tasks • Mark tasks as completed • Delete tasks from the list 🛠 Technologies Used Python | CLI | Data Structures 🔗 GitHub Repository https://lnkd.in/dsa3cQHS I’m continuously building small projects to strengthen my Python and problem-solving skills. Feedback is always welcome! #Python #Programming #GitHub #Coding #100DaysOfCode

This was my favorite chapter to write. The agent went from helpless to surgical with three plain tools. No RAG, no embeddings — just the Unix philosophy applied to AI.

I put together a local text-to-speech project using Qwen3-TTS, wrapped in a C# console app and run inside Docker. It takes text from the command line, generates MP3 or WAV files, supports custom output names, and lets you override the voice and speaking style for each run. The repo is set up with the source folder mounted into the container, so code changes are available on the next run without rebuilding the image unless dependencies change. It’s a practical example of combining .NET, Python, Docker, and local AI in a development workflow. Repository: https://lnkd.in/eDuDbjdf #dotnet #csharp #python #docker #ai #tts #machinelearning #opensource

Day 6/180 ✅ of my AI Engineering : Today I focused on Python Data Structures and revised them deeply. Topics I practiced today: • Lists • Tuples • Sets • Dictionaries Instead of just reading concepts, I spent time solving practice problems to make sure the fundamentals are really clear. During this process, I also discovered several new functions and methods that I had never noticed before. And that made me realize something interesting. Python gives developers so many powerful built-in tools that make solving problems much easier. The more I practice it, the more I understand why Python is one of the most loved programming languages in the world. ❤️ Strong fundamentals are extremely important, especially when the goal is to move towards AI and Machine Learning. Another day. Another step forward. Practice repository: https://lnkd.in/dWtj-N8C Curious to know from other developers: What made Python your favorite language, if it is one? #AI #MachineLearning #Python #DataScience #AIEngineer #LearningInPublic #BuildInPublic #PythonProgramming #StudentDeveloper #ComputerEngineering #TechStudents #FutureEngineer #CodingJourney #ProblemSolving #TechJourney #Consistency #GrowthJourney

Understanding a codebase is usually much harder than running it. A lot of the real context lives in scattered docstrings, dependency chains, comments, and team memory, which makes unboarding and handoffs slower than they should be. I’ve been build an interactive DocFlow to make that easier for Python teams. The idea is simple: Load a repo, automatically map symbols and dependencies, and explore the structure visually while reading generated docs and source code in the same workspace. What I like about this approach is that it turns codebase understanding into something you can actually inspect instead of reconstructing manually from files, folders, and guesswork. Right now, the project supports: - scanning Python repos - auto-building a flow from symbols and relationships. - exploring code in spread or sectioned views - reading docs, markdown, and source side by side - importing from local folders, demo projects, or public GitHub repos Still early, but it’s been a useful direction for thinking about onboarding, documentation drift, and navigating unfamiliar systems faster. If you’ve run into this problem in your own team, I’d be interested in how you handle codebase understanding. #documentation #python #teamwork

Many people will realize this too late. Python is quietly becoming a basic skill. According to the Stack Overflow Developer Survey, Python has consistently remained one of the most widely used programming languages in the world. AI. Data. Automation. A lot of things today start with understanding Python. The challenge? Most people don’t know where to begin. So they either overcomplicate it, buy random courses, or keep delaying it. We came across this one: A simple 14-day structure to build Python fundamentals. Because in a few years, the question won’t be “Why learn Python?” — it’ll be “Why didn’t I start earlier?”

Headline: From Simple Scripts to Systems: My Latest Python Project 🚀 Lately, I’ve been focusing on moving past basic tutorials and building tools that handle real-world logic. My latest challenge was developing a Student Management System from scratch, and it’s been a massive eye-opener for me. The shift from writing a single sequence of code to using Object-Oriented Programming changed how I think about building software. Instead of just managing data, I’m now building "objects" that interact with each other. I spent quite a bit of time ensuring that the system doesn't just work while it's running, but actually remembers the data by saving everything into JSON files. There is a specific kind of "aha!" moment when you close a terminal, reopen it, and see all your data right where you left it. It makes the code feel much more like a real product. I’m really enjoying the process of breaking down complex problems into manageable classes and methods. It’s not just about making it work anymore; it’s about making it organized and reliable. Looking forward to taking these concepts even further in my next project! #Python #CodingJourney #SoftwareDevelopment #LearningToCode #OOP #ProgrammingProgress