Month 1: From Zero to Building Real Tools.

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, the match statement
• for and while loops
• 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 / except and error handling
• The datetime, random, sys, pathlib modules
• 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 csv module — DictWriter, DictReader, delete-and-rewrite pattern
• JSON as a lightweight database — json.dumps() and json.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()), and re.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
• pip and virtual environments — managing dependencies like a real project
• Testing — writing pytest tests 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.