I Learned Python for 30 Days Straight — Here's Everything I Built
A month ago I had never written a line of Python.
I'd been meaning to start for two years. I finally did.
No bootcamp. No structured course. Just a curriculum I followed day by day, building one project per concept, committing every file to GitHub. Twenty-seven days. Four weeks. One clear theme per week. Over twenty projects, from "Hello, World!" to a class-based personal finance tracker with regex validation, JSON persistence, and CSV exports.
This is the full story.
The Structure: One Theme Per Week
Every week had a focus. Each day had one concept. Each concept ended with a project.
| Week | Theme | Days |
|---|---|---|
| Week 1 | The Basics | 1–7 |
| Week 2 | Functions & Organisation | 8–13 |
| Week 3 | Data Structures | 15–20 |
| Week 4 | Files & Real Programs | 22–27 |
The numbered days have gaps — those were rest or catch-up days. That rhythm mattered more than I expected. Showing up 27 out of 30 days is still 27 days of practice.
Week 1 — Learning the Language
Theme: Python basics. Getting the environment working. Writing the first real programs.
What I learned
-
print(),input(), f-strings, data types - Variables, string methods,
int(),float() -
if/elif/else, thematchstatement -
forandwhileloops - Functions (introduced early, because my projects demanded them)
What I built
| Project | Highlight |
|---|---|
| Hello World + Greeter | Four different ways to print a greeting |
| String Methods Playground | Every major string method in one file |
| Calculator | Input validation with isdecimal() before the math |
| Number Guessing Game | Difficulty levels with match, loop-based game logic |
| Multiplication Table | Nested while and for loops |
| Password Validator |
any() with a generator — the first genuinely elegant thing I wrote |
| Text Adventure Game | Rooms, inventory, random beast, win/lose conditions |
The moment that clicked
The password validator using any(char.isupper() for char in password). I found any() while Googling, dropped it in, and it worked perfectly. That kind of side-discovery while building is what makes self-directed learning stick.
Biggest surprise
Python reads like English. I expected cryptic syntax. I got something close to readable logic on day one.
Week 2 — Functions & Organisation
Theme: Writing code that's not just correct, but clean. One function, one job.
What I learned
- Function parameters, return values, scope
-
try/exceptand error handling - The
datetime,random,sys,pathlibmodules - File I/O basics — writing and reading with
pathlib - Docstrings and
sys.exit()
What I built
| Project | Highlight |
|---|---|
| Tip Calculator |
removesuffix() to handle $42 or 42 equally |
| Days-Until Calculator |
try/except ValueError + else on a try block |
| Dice Roller with History |
sys.exit(), docstrings, session-persistent history list |
| Password Manager | Caesar cipher encryption, json + pathlib file persistence |
| Adventure Game (refactored) | Proper input validation on room names, cleaner beast() logic |
The moment that clicked
try/except with the else clause. The else block on a try only runs if no exception was raised. I didn't know it existed. The moment I used it for the break in the days-until calculator, it felt like discovering a hidden tool.
Biggest surprise
Refactoring Week 1 code wasn't boring — it was genuinely satisfying. Seeing messy scripts become clean, purposeful functions felt like real progress.
Week 3 — Data Structures
Theme: Designing programs around data, not the other way around.
What I learned
- Lists —
append(),remove(),pop(),index(), filtering - List comprehensions
- Dictionaries — nested,
.items(),.values(),del - Sets and tuples — when to use each
- Multi-file project structure — splitting data and logic into separate modules
What I built
| Project | Highlight |
|---|---|
| To-Do List App |
pop().append() chain to move tasks between lists in one line |
| Number Filter | List comprehensions + prime algorithm using pow(n, 0.5)
|
| Contact Book | Nested dictionaries — name → phone, email, address |
| Inventory System | Three levels of nesting — category → item → details |
| Python Quiz App | Tuples for immutable data, dict(zip()), multi-file structure, high score persisted to file |
The moment that clicked
dict(zip(qdata.markers, qdata.options[val])) in the quiz app. Zipping two lists into a dictionary on a single line, then using it to map A/B/C/D to options dynamically. That felt like writing real Python, not tutorial Python.
Biggest surprise
Data structures aren't just storage — they're design decisions. Choosing a tuple over a list, or a dictionary over a list of lists, shapes the entire program. I started thinking about the shape of data before writing functions.
Week 4 — Files & Real Programs
Theme: Programs that do something permanent. Files, formats, real-world data handling.
What I learned
- File I/O —
open(), read/write/append modes,os.remove() - The
csvmodule —DictWriter,DictReader, delete-and-rewrite pattern - JSON as a lightweight database —
json.dumps()andjson.loads() - Regular expressions —
re.fullmatch(),re.search(),re.findall(), capture groups - Object-Oriented Programming intro —
class,@classmethod, grouping methods
What I built
| Project | Highlight |
|---|---|
| Note-Taking App | Full CRUD — create, view, update, delete — persisted to .txt files |
| Expense Tracker | CSV write/read with DictWriter / DictReader, delete-and-rewrite |
| Email Validator |
re.fullmatch() regex pattern + email-validator library comparison |
| Log Parser |
re.findall() with capture groups extracting IPs and timestamps from real log data |
| Personal Finance Tracker | JSON + CSV + regex + full CRUD + monthly report generation + CSV export |
| Finance Tracker (OOP) | Same app, refactored into a Finance class with @classmethod methods |
The moment that clicked
The log parser. Eight lines of code. A regex pattern. An access.log file. Output: clean IP address and timestamp pairs extracted from every line. That's when regex stopped feeling like noise and started feeling like a superpower.
Biggest surprise
OOP is about grouping, not just syntax. Wrapping finance.py functions into a Finance class didn't change what the code does — it changed how it's organised. That distinction, once I saw it, changed how I think about designing programs.
Everything I Built in 30 Days
| # | Project | Week | Key Concepts |
|---|---|---|---|
| 1 | Hello World + Greeter | 1 |
print(), input(), f-strings |
| 2 | String Methods Playground | 1 | String methods |
| 3 | Calculator | 1 | Input validation, if/elif/else
|
| 4 | Number Guessing Game | 1 |
while, random, match
|
| 5 | Multiplication Table | 1 |
for loop, nested while
|
| 6 | Password Validator | 1 |
any(), string methods |
| 7 | Text Adventure Game | 1 | Functions, global state, game logic |
| 8 | Tip Calculator | 2 | Functions, return, removesuffix()
|
| 9 | Days-Until Calculator | 2 |
try/except, datetime
|
| 10 | Dice Roller with History | 2 |
random, sys, docstrings |
| 11 | Password Manager | 2 | File I/O, json, Caesar cipher |
| 12 | To-Do List App | 3 | Lists, filtering, match
|
| 13 | Number Filter | 3 | List comprehensions, prime algorithm |
| 14 | Contact Book | 3 | Nested dictionaries |
| 15 | Inventory System | 3 | 3-level nested data |
| 16 | Python Quiz App | 3 | Tuples, zip(), multi-file modules |
| 17 | Note-Taking App | 4 | File CRUD, os, if __name__
|
| 18 | Expense Tracker | 4 |
csv, DictWriter, DictReader
|
| 19 | Email Validator | 4 |
re.fullmatch(), regex |
| 20 | Log Parser | 4 |
re.findall(), capture groups |
| 21 | Personal Finance Tracker | 4 | JSON + CSV + regex + full CRUD |
| 22 | Finance Tracker (OOP) | 4 |
class, @classmethod
|
All of it is on GitHub:
👉 github.com/Omk4314/progress-on-python
What Changed in 30 Days
How I think about errors. Week 1 me panicked at red text. Month 1 me reads the traceback, identifies the line, and knows where to look. Errors are information, not failures.
How I think about data. I used to design code and shove data into variables. Now I design the data structure first and write functions around it. That inversion came somewhere in Week 3 and never went away.
How I think about programs. Week 1 programs ran once and died. Week 4 programs write to files, read them back, export CSV reports, validate inputs with regex, and persist high scores between sessions. They feel like software.
How I think about code quality. The first version of anything I write now has one job per function, docstrings, guard clauses, and if __name__ == "__main__":. None of that was natural on Day 1. All of it is by Day 27.
What I'd Tell Myself on Day 1
- Build things, don't just read about them. Every concept landed harder when it was inside a real project.
- Commit every day, even the small days. The GitHub streak is a chain worth keeping.
-
Google while building, not before. I learned
any(),removesuffix(),dict(zip()), andre.findall()by searching for solutions to problems I was actually stuck on. - Refactoring old code is progress. Going back to Week 1 files in Week 2 and making them better wasn't busy work. It was consolidation.
- The terminal stops being scary faster than you think. By Day 5 I was looking forward to opening it.
What's Next
Month 2 has a clear agenda:
-
OOP properly —
__init__, instance variables, inheritance,__str__,__repr__ - APIs — pulling real data from the internet into Python programs
-
pipand virtual environments — managing dependencies like a real project -
Testing — writing
pytesttests for my own code - A multi-file project — something big enough to need proper architecture
One month down. The foundation is solid. Time to build something on top of it.
If you're learning Python alongside me, drop a comment — I want to see what you're building too.
See you in Month 2. 🐍
30 days. 22 projects. One language. Still going.