DEV Community: Om Kolhapure

Week 3: Lists, Dicts, and Why Data Structures Matter.

Om Kolhapure — Tue, 26 May 2026 17:21:23 +0000

Weeks 1 and 2 were about learning the language.

Week 3 was about learning how to hold data.

Every meaningful program stores and organises information — lists of tasks, books of contacts, inventories of products. This week I stopped treating data as a side effect of my programs and started designing programs around data. Lists, dictionaries, nested structures, sets, tuples — six days that changed how I think about writing Python.

Here's what happened.

Day 15 — Lists Deep Dive: A Real To-Do App

Day 15 started with a question: what's the most practical thing I can build with a list?

A to-do app. Add tasks, remove them, mark them complete, filter by status. I built the whole thing using list methods — append(), remove(), pop(), index() — and kept the clean one-function-one-job structure I picked up in Week 2:

import sys

pending_tasks = []
completed_tasks = []


def main():
    print("\n\tWelcome to the app!")
    while True:
        while True:
            usr = input('''What would you like to do?(choose the corresponding number)\n1.Add Tasks
                        \n2.Mark complete\n3.View Tasks\n4.Remove Task\n5.Press 'q' to quit\n-> ''')

            if usr == "1" or usr == "2" or usr == "3" or usr == "4" or usr == "q":
                break
        match usr:
            case "1":
                add_task()
            case "2":
                mark_complete()
            case "3":
                filters()
            case "4":
                remove_task()
            case "q":
                sys.exit()


#Add
def add_task():
    '''Adds Task to pending_tasks'''
    new_task = input("Enter the new task: ").strip()
    pending_tasks.append(new_task)
    print("Task Added")
    print_tasks(pending_tasks)


#Remove
def remove_task():
    '''Removes the Task mentioned by the user'''
    rmove = input("Enter the task you want to remove: ").strip()
    if rmove in pending_tasks:
        pending_tasks.remove(rmove)
        print_tasks(pending_tasks)
    elif rmove in completed_tasks:
        completed_tasks.remove(rmove)
        print_tasks(completed_tasks)
    else:
        print("Task not found!")


#Mark Complete
def mark_complete():
    '''Transfers the task completed by the user from pending_tasks to completed_tasks'''
    complete = input("Enter the task you want to mark complete: ").strip()
    if complete in pending_tasks:
        completed_tasks.append(pending_tasks.pop(pending_tasks.index(complete)))
    elif complete in completed_tasks:
        print("Task already completed!")
    else:
        print("Task not Found!")

#Filter by status
def filters():
    '''Let's user filter between pending tasks and completed tasks'''
    filter_task = input("Which tasks do you want to see?(Pending/Completed): ").strip().lower()
    if filter_task == "pending":
        if pending_tasks:
            print_tasks(pending_tasks)
        else:
            print("No Task Found!")
    elif filter_task == "completed":
        if completed_tasks:
            print_tasks(completed_tasks)
        else:
            print("No Task Found!")
    else:
        print("Invalid input!")

# print tasks
def print_tasks(t):
    '''prints the list of tasks to the screen'''
    for tsk in t:
        print(tsk)

#calling the main function
main()

The line that clicked hardest: completed_tasks.append(pending_tasks.pop(pending_tasks.index(complete))). That single chain finds the task by name, removes it from pending, and returns it — so it lands straight into completed_tasks. One line doing exactly the right job. That's when list methods started feeling like a real toolkit rather than a list of things to memorise.

Day 16 — List Comprehensions: Less Code, Same Power

Day 16 introduced one of Python's most beloved features — list comprehensions. Build a filtered or transformed list in a single, readable line instead of writing a full loop.

I built a number filter that splits 1–10 into even, odd, and prime — with a custom is_prime() function handling the prime logic:

def main():
    numbers = list(range(1,11))
    even_numbers = [num for num in numbers if num % 2 == 0]
    odd_numbers = [num for num in numbers if num % 2 != 0]
    prime_numbers = [num for num in numbers if is_prime(num)]
    print(even_numbers)
    print(odd_numbers)
    print(prime_numbers)


def is_prime(n):
    if n < 2:
        return False
    else:
        for i in range(2, int(pow(n, 0.5)) + 1):
            if n % i == 0:
                return False
    return True

main()

Output:

[2, 4, 6, 8, 10]
[1, 3, 5, 7, 9]
[2, 3, 5, 7]

Two things hit me at once here:

List comprehensions read like sentences: "give me every num from numbers if it's even." Once you see it, you can't unsee it — a regular for loop starts feeling like too many words.
The prime checker uses pow(n, 0.5) — the square root of n — to limit how many divisors it needs to test. That's a genuine algorithmic optimisation. Week 1 me would have looped all the way to n. Discovering that while building felt like a small unlock.

Day 17 — Dictionaries: A Contact Book

Dictionaries were the data structure I'd been reaching for since Week 1. Key-value pairs — the natural way to model real-world objects.

I built a contact book: name as the key, a nested dictionary of details as the value. Add contacts, view them, delete them:

#building a contact book
# contact -> information = mobile number, email, address
import sys
contacts = {}
app_running = True


def main():
    '''main function'''
    global app_running
    while app_running:
        print("\n\tWELCOME TO CONTACT BOOK\n")
        while True:
            ask_user = input('''What would you like to do?\n
                            (Choose the corresponding number of the task you want to perform)\n
                            1. Add/Save new contact\n
                            2. View contacts\n
                            3. Delete contact\n
                            (press 'q' to quit)\n -> ''').strip().lower()
            if ask_user == "1" or ask_user == "2" or ask_user == "3" or ask_user == "q":
                break

        match ask_user:
            case "1":
                save_contact()
            case "2":
                show_contacts()
            case "3":
                delete_contact()
            case "q":
                sys.exit()


def save_contact():
    '''Saves user's contact'''
    global app_running
    while app_running:
        if not app_running:
            break
        name = input("Enter name: ")
        user = {}
        contacts[name] = user
        while True:
            while True:
                user["mob"] = input("Enter Mobile No.: ").strip()
                user["email"] = input("Enter email: ").strip()
                if user["mob"].isdecimal():
                    break
                else:
                    print("Invalid Mobile No.")

                if "@" in user["email"]:
                    break
                else:
                    print("Invalid email!")
            user["add"] = input("Enter address: ").strip()   
            print("Contact saved...\n")
            show_contacts()
            break
        while True:
            response = input("Do you want to save another contact?(yes/no)? ")
            if response == "yes" or response == "no":
                break
        if response == "no":
           break


def show_contacts():
    '''Shows contact's of the user'''
    if contacts:
        print_contact()
    else:
        print("No Contacts found!")

def delete_contact():
    '''Deletes a contact'''
    show_contacts()
    delete = input("Enter the name of the you want to delete: ")
    if delete in contacts:
        del contacts[delete]
    else:
        print("No contact found!")


def print_contact():
    '''prints contacts'''
    for contact, user_info in contacts.items():
        print(f"Contact name: {contact}\nPhone No.: {user_info['mob']}\nEmail: {user_info['email']}\nAddress: {user_info['add']}\n")


#Calling the main function
main()

The structure that made this work: contacts[name] = user where user is itself a dictionary of mob, email, and add. That's a dictionary inside a dictionary — my first proper nested data structure, and it arrived naturally because the problem required it.

.items() in print_contact() was also new — iterating over both keys and values simultaneously instead of just one. Once you know it exists, you can't stop using it.

Day 18 — Nested Data: An Inventory System

The contact book was one level of nesting. Day 18 went three levels deep: category → item → details:

#Building an inventory system
#category-> item-> details
global price
inventory = {
    "Electronics": {
        "Laptop": {"quantity": 10, "price": 999.99, "supplier": "TechCorp"},
        "Mouse":  {"quantity": 50, "price": 25.50,  "supplier": "GadgetInc"}
    },
    "Furniture": {
        "Chair": {"quantity": 20, "price": 150.00, "supplier": "ComfortCo"}
    }
}


def main():
    cat = input("Enter the category you want the total value of (furniture/electronics): ").title()
    total_value(inventory[cat])

def total_value(inventory_item):
    products = {}
    products = inventory_item
    total = 0
    for product_info in products.values():
        total += product_info["quantity"] * product_info["price"]
    print(total)


main()

Ask for Electronics: (10 × 999.99) + (50 × 25.50) = 11,274.90.
Ask for Furniture: 20 × 150.00 = 3,000.00.

What struck me: I spent more time thinking about how to structure the dictionary than writing the functions. The shape of the data determined the shape of the code. That shift — designing data first, then writing logic around it — felt like a genuinely new layer of thinking.

Day 19 — Sets & Tuples

Day 19 was the two data structures I hadn't touched yet.

Tuples — like lists, but immutable. Once created, they can't be changed. Perfect for data that must stay fixed: config values, coordinates, question banks. The quiz project on Day 20 stores all questions and answers as tuples for exactly this reason — nothing can accidentally overwrite them mid-run.

Sets — unordered collections with no duplicates. The killer use case: deduplication. Have a list and want only the unique values? Convert to a set. Sets also have significantly faster membership checks than lists for large collections.

The mental model I settled on by end of day:

Need order + mutability? → List
Need key-value lookup? → Dictionary
Need immutable, fixed data? → Tuple
Need uniqueness + fast lookup? → Set

Day 20 — The Week 3 Project: A Python Quiz App

The end-of-week project brought together everything from the week — dictionaries, tuples, file I/O, try/except, randomisation, and a proper multi-file structure. The most architecturally considered thing I've built.

Two files: qdata.py holds all the quiz data, quiz.py runs the game.

`qdata.py` — The Data Layer

questions = (
    "How many parameters does a print statement have?",
    "Which functions returns the ASCII number associated with a char?",
    "What does the method dict.keys() return?",
    "What is the  difference between a list and a tuple?",
    "What is the full form of json?",
    "What does the function json.dumps() does?",
    "What does the function json.loads() does?",
    "In a dictionary, what does (dict_name['key']) this syntax return?",
    "Methods and functions are the same.",
    "What type of datatype does the input() function return?",
)

answers = (
    "3",
    "ord()",
    "view object",
    "A list can be modified but a tuple cannot be modified",
    "Javascript Object Notation",
    "Converts dictionary to a str",
    "Converts str to a dictionary",
    "Returns the value associated with the given key",
    "False",
    "str",
)

qna = {}
for i in range(len(questions)):
    qna[questions[i]] = answers[i]

options = [
    ["1", "2", "3", "4"],
    ["list()", "chr()", "ord()", "int()"],
    ["tuple of keys", "list of keys", "view object", "object"],
    ["They are both the same", "A list can be modified but a tuple cannot be modified", "A tuple can be modified but a list cannot be modified", "We can access an element in lists but not in tuples"],
    ["Java Subject Object Notes", "Javascript Object Notation", "Jackle and Son Oxygen Needs", "Java SON"],
    ["Closes the file", "Converts str to a dictionary", "Converts dictionary to a str", "Clears the file"],
    ["Creates a new file", "Converts dictionary to a str", "Converts str to a dictionary", "Opens the file"],
    ["Returns the key", "Returns the value associated with the given key", "Returns all the keys", "Returns the dictionary name"],
    ["True", "False", "Both True and False", "None of the above"],
    ["float", "integer", "character", "str"]
]

markers = ["A", "B", "C", "D"]

Questions and answers are tuples — immutable, so nothing can accidentally overwrite them at runtime. The qna dictionary maps each question directly to its correct answer, built dynamically with a for loop. Clean and easy to extend — add a question to questions, an answer to answers, options to options, and the game picks it up automatically.

`quiz.py` — The Game Engine

from pathlib import Path
import random
import qdata
import sys

global val
global score
num = list(range(0, 10))
file = Path("score.txt")

def main():
    while True:
        ask_user = input("Wanna play the fun python quiz?(yes/no) ").strip().lower()
        if ask_user == "yes" or ask_user == "no":
            break
    if ask_user == "yes":
        while True:
            score = 0
            random.shuffle(num)
            for n in num:
                val = n
                marked_options = dict(zip(qdata.markers, qdata.options[val]))
                display_question(val)
                display_option(marked_options)
                score = user_choice(val, score, marked_options)
            high_score(score)
            while True:
                usr = input("Wanna play again(yes/no)? ").strip().lower()
                if usr == "yes" or usr == "no":
                    break
            if usr == "no":
                sys.exit()
    else:
        sys.exit()


def display_question(val):
    print(qdata.questions[val])

def display_option(marked_options):
    for marker,option in marked_options.items():
        print(f"{marker}. {option}")

def user_choice(val, score, marked_options):
    while True:
        try:
            user_ans = input("Choose your option: ").strip().upper()
            if marked_options[user_ans] == qdata.qna[qdata.questions[val]]:
                score += 4
                print("You got it right!")
            else:
                score -= 1
                print("You are wrong:(")
            print(f"Current Score: {score}")
            return score
        except KeyError:
            print("Choose A/ B/ C/ D!!")

def high_score(score):
    h_score = 0
    if h_score < score:
        h_score = score
        file.write_text(f"High score: {h_score}")
        print(file.read_text())
    else:
        file.write_text(f"High scores: {h_score}")

main()

Everything I've learned in three weeks lives inside this project:

Tuples for immutable question and answer data
Dictionaries for the qna lookup table and marked_options per question
random.shuffle() so questions arrive in a different order every game
dict(zip()) to pair A/B/C/D markers to options on the fly
try/except KeyError to catch invalid answers gracefully instead of crashing
pathlib + file I/O to persist the high score between sessions
Multi-file structure — quiz.py imports qdata as a module, keeping data and logic completely separate

My current high score saved to score.txt: 35.

📁 What I Built This Week

Project	File	Concepts Used
To-Do List App	`todo_list.py`	Lists, `append`, `remove`, `pop`, `index`, filtering
Number Filter	`number_filter.py`	List comprehensions, prime algorithm, `pow()`
Contact Book	`contact.py`	Dictionaries, nested dicts, `.items()`, `del`
Inventory System	`inventory.py`	Nested dictionaries, `.values()`, data-first design
Python Quiz App	`python-quiz/quiz.py` + `qdata.py`	Tuples, dicts, `zip()`, `shuffle()`, `try/except`, file I/O, multi-file modules

All the code is on GitHub — every week, every file:
👉 github.com/Omk4314/progress-on-python

What Actually Clicked This Week

Data structures aren't just storage — they're design decisions. Choosing between a list, dictionary, tuple, or set shapes how the entire program works.
Nested dictionaries feel natural once you need them. The contact book required them. I didn't force the structure — the problem suggested it.
List comprehensions are more readable, not just shorter. [num for num in numbers if is_prime(num)] reads like a plain description of what you want.
Separating data from logic is powerful. qdata.py and quiz.py as two files meant I could change every question without touching the game engine once.
try/except KeyError is the right tool when dictionary lookups might fail on bad user input. Cleaner than checking if key in dict every time.

What I Want to Learn Next

Week 4 is on the horizon and I already know what's coming:

Object-Oriented Programming — classes and instances. The to-do app and contact book are straining against the limits of functions-and-globals. Objects feel like the natural next step.
Inheritance — sharing behaviour without copying code
__str__ and __repr__ — making objects print like real things
Larger multi-file projects — the quiz app gave me a taste of real structure

Three weeks in. The programs are starting to look like software.

If you're following along or learning Python yourself, drop your projects in the comments — beginner work deserves to be seen.

See you in Week 4. 🐍

Week 3 complete. I finally understand why everyone says "it's all about the data structures."

Week 2: From Sphaghetti to Functions

Om Kolhapure — Sun, 17 May 2026 11:12:16 +0000

Week 1 was about getting things to work.

Week 2 was about getting things to work properly.

The difference is bigger than I expected. I spent six days going back to code I was already proud of and realising it could be cleaner, safer, and smarter. Functions, error handling, built-in modules, file I/O — this week the pieces stopped feeling like separate topics and started feeling like a toolkit.

Here's what happened.

Day 8 — Functions: One Job, One Function

The rule I was given for Day 8: every function does ONE thing.

That sounds obvious until you look at your old code and realise every function you wrote does about four things. I went back to the adventure game from Week 1 and refactored it properly — breaking out start_game(), print_story(), print_location(), move_player(), beast(), check_up(), pick_up(), and game_end() into eight focused functions.

But the real lesson hit me when I built the tip calculator from scratch with clean separation from the start:

def main():
    #Ask user to input bill, tip, people
    bill = input("Enter total bill: ").strip()
    tip = input("How much tip would you like to give?: ").strip()
    people = input("Enter number of people: ").strip()
    per_person = calculate(bill, tip, people)
    print(f"Each person must cobntribute {per_person}$.")

def calculate(bill, tip, people):
    #Convert from str to int and calculate the split
    if "$" in bill:
        bill = bill.removesuffix("$")
    bill = float(bill)
    if "%" in tip:
        tip = tip.removesuffix("%")
    tip = int(tip) / 100
    people = int(people)
    return round((bill + (bill * tip)) / people, 2)

main()

main() talks to the user. calculate() does the math. Neither steps on the other's toes.

Two things I didn't expect to love here: removesuffix() — so you can type "$42" or just "42" and it handles both — and how clean return makes functions feel. You hand it data, it hands you an answer. No side effects, no surprises.

Day 9 — Parameters & Return Values

Day 9 was about really understanding what flows into and out of functions. The tip calculator covered this well — calculate() takes three parameters, does one job, and returns one value.

What clicked: functions are just machines. You feed them inputs, they produce an output. Once I started thinking that way, writing them felt much more intentional. Every parameter has a purpose. Every return value means something.

I spent extra time making calculate() handle edge cases:

What if someone types $42 with a dollar sign? → removesuffix("$") strips it
What if they type 15% instead of 15? → removesuffix("%") strips that too
Division by zero for people? → int(people) would be 0 and the function would crash — something I noted to fix with error handling later

This kind of thinking — what could go wrong? — is new for me. Week 1 me just hoped the user typed the right thing.

Day 10 — Scope & Modules

Day 10 was scope — understanding what variables live where — and modules, which is how Python lets you split code across files.

The adventure game got its cleanest version yet. Better input validation was added so the game no longer silently accepts invalid room names:

def move_player():
    global player_location
    while True:
        go = input("\nWhere would you like to go?\nbedroom\nkitchen\nliving room\n\n ")
        if go not in locations:
            print("Invalid location please choose from the list")
        if player_location == go:
            print(f"Already in {player_location}")
        else:
            player_location = go
            print_location()
            beast()
            if not game_state:
                break
            check_up()
            break

The retry logic in beast() also got cleaner:

def beast():
    global player_location
    global game_state
    beast_location = random.choice(locations)
    if beast_location == player_location:
        print("you are Dead")
        retry_input = input("Would you like to play again?(yes/no) ")
        if retry_input != "yes":
            game_state = False
        player_location = "bedroom"
    else:
        print("growlssss.........The beast is nearby")

The big scope lesson: global variables are a trade-off. They're convenient for a small game, but they make bigger programs hard to reason about. I'm already starting to see why Week 3 will probably involve classes.

Day 11 — Error Handling: `try/except`

This was one of my favourite days. Before try/except, my programs crashed the moment a user did something unexpected. After it, they handle the unexpected and keep running.

I built a days-until calculator — it tells you how many days until any date you enter:

from datetime import date
#Take input from user for target
while True:
    try:
        user_input = input("Enter you target date in (dd/mm/yyyy): ")
        day, month, year = user_input.split("/")
        day = int(day)
        month = int(month)
        year = int(year)
    except ValueError:
        print("Enter the date, month, year in dd/mm/yyyy format")
    else:
        break


target = date(year, month, day)
now = date.today()
days_until = target - now
print(f"There are {days_until.days} days until {user_input}")

Three things that clicked here at once:

try/except ValueError catches the crash when the user types something that can't be split or converted to int — instead of crashing, it loops and asks again
else on a try block — I didn't know this existed. It runs only if no exception was raised. Perfect for the break that exits the loop
from datetime import date — my first real standard library module. date.today() and date arithmetic (target - now) feel almost magical

Type "christmas" into my program and it says "Enter the date, month, year in dd/mm/yyyy format."
Week 1 me's program would have thrown a wall of red text.

Day 12 — Built-in Libraries: `random`, `datetime`, `sys`

Day 12 was about getting comfortable with Python's standard library. I built a dice roller that tracks your roll history and lets you view it mid-session:

from random import randint
import sys


previous_values = []
global value


def roll():
    '''Checks the user input and then rolls the dice and stores the value in history'''
    while True:
        while True:
            roll_dice = input("Roll the dice?(yes/ no) [press h to view history] ").strip().lower()
            if roll_dice == "yes" or roll_dice == "no" or roll_dice == "h":
                break
        if roll_dice == "no":
            sys.exit()
        elif roll_dice == "h":
            if previous_values:
                check_history()
            else:
                print("There is no history")
        else:
            value = randint(1, 6)
            print(value)
            history(value)


def history(store):
    previous_values.append(store)


def check_history():
    print(previous_values)

#Calling the roll function
roll()

New things that appeared this week:

Docstrings — '''Checks the user input...''' right under the function definition. First time I've written proper in-code documentation
sys.exit() — a clean way to quit a program from inside a function, without needing a flag variable
from random import randint — importing just the function I need instead of the whole module

Three focused functions, clear responsibilities, history that persists through the session. This felt like real program design, not just scripts.

Day 13 — The Week 2 Project: A Password Manager

The end-of-week project brought everything together: functions, file I/O, modules, error handling, and a Caesar cipher for encryption. This is the most complex thing I've built so far.

Features:

🔐 Store passwords encrypted to a file
🔍 Retrieve and decrypt them by site name
📁 Persists between sessions using json + pathlib
🔑 Caesar cipher encryption on every stored password

from pathlib import Path
import json
import random
import sys

global file
global key
key = random.randint(3, 25)
file = Path("passwords.txt")
usr_data = {}


#Take command from the user
def command():

    while True:
        com = input("Enter command(store/retrive/'q' to quit): ").strip().lower()
        if com == "store" or com == "retrive" or com == "q":
            break

    if com == "store":
        password_site()
    elif com == "retrive":
        retrive_password()
    else:
        sys.exit()

#Store the password
def password_site():
    while True:
        site_name = input("Enter site name: ")
        passwrd = input("Enter password: ").lower()
        usr_data[site_name] = cipher(passwrd, key)
        while True:
            retry = input("Do you want to store a new password(yes/no)? ").lower()
            if retry == "yes" or retry == "no":
                break
        if retry == "no":
            file.write_text(json.dumps(usr_data, indent = 4))
            print("Saved to file..")
            return

#retrive the password
def retrive_password():
    contents = json.loads(file.read_text())
    site = input("Enter site name to retrive your password: ")
    if site in contents:
       usr_password = decrypt(contents[site], key)
       print(f"Your password for {site} is {usr_password}")
    else:
        print(f"Not found site name: {site}")

#Encrypting the password using ceasar cipher
def cipher(strng, k):
    new_strng = ""
    for char in strng:
        if char.isalpha():
            if char.islower():
                c_num = ((ord(char) - ord("a")) % 26) + ord("a")
                new_strng += chr(c_num)
            elif char.isupper():
                ch_num = ((ord(char) - ord("A")) % 26) + ord("A")
                new_strng += chr(ch_num)
        else:
            new_strng += char
    return new_strng

#Decrypting the password 
def decrypt(pss, k):
    new_pss = ""
    for char in pss:
        if char.isalpha():
            if char.islower():
                char_num = ((ord(char) - ord("a")) % 26) - ord("a")
                new_pss += chr(char_num)
            elif char.isupper():
                chr_num = ((ord(char) - ord("A")) % 26) - ord("A")
                new_pss += chr(chr_num)
        else:
            new_pss += char
    return new_pss

command()

This week's project felt different from last week's. The adventure game was fun. This one felt useful. Real file persistence, real encryption logic, real user commands. I stored a password, closed the program, reopened it, retrieved the password — and it worked. That moment hit differently.

📁 What I Built This Week

Project	File	Concepts Used
Tip Calculator	`tip.py`	Functions, parameters, return values, `removesuffix()`
Days-Until Calculator	`days_until.py`	`try/except`, `datetime`, date arithmetic
Dice Roller with History	`dice.py`	`random`, `sys`, docstrings, list history
Password Manager	`passwords_manager.py`	File I/O, `json`, `pathlib`, Caesar cipher, all of the above
Adventure Game (refactored)	`game.py`	Scope, input validation, cleaner function design

All the code is on GitHub — Week 1 and Week 2, every file:
👉 github.com/Omk4314/progress-on-python

What Actually Clicked This Week

One function, one job. Once I started following this rule, my code became easier to read, easier to fix, and easier to build on.
try/except changes everything. Programs that handle bad input gracefully feel professional, not just functional.
The standard library is enormous. datetime, random, pathlib, json, sys — all built in, nothing to install. I've barely scratched the surface.
File I/O makes programs feel real. The moment my password manager wrote to a file and read it back, it stopped feeling like a script and started feeling like software.
Refactoring is a skill. Going back to Week 1 code and improving it wasn't boring — it was genuinely satisfying.

What I Want to Learn Next

Week 3 is going to push further:

Classes and OOP — I can feel the limits of global variables and I think objects are the answer
More on file I/O — reading CSVs, writing logs
Bigger projects — something that ties multiple files together properly
Maybe some APIs — pulling real data into Python feels like the next unlock

If you're following along or learning Python yourself, drop a comment — I'd love to see what you're building too.

See you in Week 3. 🐍

Two weeks in. The programs are getting real. So is the learning.

What I learned in Week 1

Om Kolhapure — Sun, 10 May 2026 11:00:10 +0000

What I Learned in Week 1 of Python — And Why I'm Already Hooked

I've been saying "I'll learn to code" for two years.

Last Monday, I actually did something about it.

No bootcamp, no cohort — just Python, VS Code, and a stubbornly blank terminal staring back at me. Seven days later, I've built a calculator, a number guessing game with difficulty levels, a password validator, a multiplication table generator, and a full text-based adventure game with rooms, inventory, and a win condition.

This is what Week 1 actually looked like.

Day 1 — Hello, World (and Hello, `print()`)

Before writing a single line of Python, I spent way too long on setup — installing Python 3.12, VS Code, the Python extension, figuring out why the terminal wasn't running my file. The setup tax is real.

But once I got there, I didn't just write one print() and move on. I explored every way Python can greet someone:

#My first python code
print("Hello, World")
#Making a greeter!!
#Ask user for his/her name
name = input("What's your name? ")
#methods to display the greeting on the screen as hello, name(whatever the name might be)
#explicitly mentioning value of end in print function
print("Hello, ", end = " ")
print(name)
#Giving two arguments to the print function
print("Hello,", name)
#Concatening Strings
print("Hello, " + name)
#Using f-strings
print(f"Hello, {name}") #The most commonly used one

That last one — the f-string — immediately became my favourite. It reads almost like writing a sentence with blanks. I didn't expect Python to feel this close to plain English on day one.

Day 2 — String Methods and the Beauty of Built-ins

Day two was variables, data types, and getting comfortable with what Python can do to strings out of the box. I wrote a small methods playground:

word = "library"
print(word.strip())      #Strips all the white spaces from left and right side of a str
print(word.capitalize()) #Capitalizes only first letter of the first word
print(word.title())      #Capitalizes first letter of every word
print(word.split()) #spits the word at whitespaces and returns an array of substring
print(word.split("r")) #splits the word at every r it will encounter 
print(word.split("r", 1)) #splits the word from the first r it encounters

#The above methods can also be written in the following way
print(word.split().title().split("r", 1))

What surprised me: how many useful things are just built into the language. No imports, no setup — just word.something() and it works. Coming from zero experience, that felt like a generous head start.

Day 3 — User Input + My First Real Program

This was the day things started feeling real. I built a calculator — and pushed it further by adding input validation so the program doesn't crash on bad data:

#Asking for input from user
x = input("What's x? ")
y = input("What's y? ")
#Check if the user's input is a digit
if x.isdecimal() and y.isdecimal() :
    x = int(x)
    y = int(y)
    #Display arthematic opreations on the screen
    print(x + y) 
    print(x - y)
    print(x * y)
    if y == 0 :
        print("Cannot divide by zero")
    else:
        print(x / y)
else:
    print("Invalid input!!")

The isdecimal() check came from Googling "how do I stop Python from crashing when someone types letters." That one search taught me more than an hour of reading would have.

Tiny win: Handling division by zero before Python could throw an error felt like writing my first real defensive code.

Day 4 — Conditionals and a Game With Difficulty Levels

if, elif, else. The traffic lights of programming.

I built a number guessing game — and pushed it further by adding difficulty levels and Python's match statement, which I stumbled onto and immediately loved:

import random

#declaring game state variable 
gameRunning = True

#Ask the user for difficulty and then set the range according to the difficulty selected
difficulty = input("Choose difficulty:\n\tEasy\n\tMedium\n\tHard\n").title()
x = 1
match difficulty:
    case "Easy":
          y = 100
    case "Medium":
         y = 500
    case "Hard":
         y = 1000
    case _:
        print("Invalid input: Please select from the given choices!")

#Generating random number and storing it in a variable
randomNumber = random.randint(x, y)
#Asking the user for input of the number
number = int(input("What's the number I am thinking about?: "))
#Tracking attempt's taken by user to guess the number
attempt = 1

while gameRunning == True:
    if number == randomNumber:
        print("Correct, you got me!")
        gameRunning = False
    elif number > randomNumber:
        print("too high")
        number = int(input("Guess Again: "))
        attempt += 1
    else:
        print("too low")
        number = int(input("Guess Again: "))
        attempt += 1
print(f"You took {attempt} attempts to guess the number!")

I played Hard mode probably ten times before moving on. When you build something fun, the learning sticks.

Day 5 — Loops: Two Programs, One Concept

Loops were the first concept that made me genuinely pause. for clicked fast. while required me to think differently — "keep doing this until something is true."

I built two programs to drill both.

Multiplication Table Generator

#setting an active flag
active = True
#Using while to run the generator as long as the user wants
while active:
    #Take input from the user
    #check if it is positive if not prompt the user Again
    while True:
        number = int(input("\nEnter a number: "))
        if number > 0:
            break
    #Using for loop iterate generate the multiplication table
    print()
    for i in range(10):
        print(f"{number} * {i + 1} = {number * (i + 1)}")
    print()
    #Asking the user if he wants to continue??
    repeat = input("Do you want to enter another number(yes/no)? ").lower()
    if repeat == "no":
        active = False

Password Validator

#Adding a error1, erro2, erro3 variables to make the code readable
error1 = "\nThe password must atleast be 8 characters long"
error2 = "The password must contain atleast an uppercase letter and it must be alphanumeric"
#print the criteria and check if the given password meets the criteria
print("The following is the criteria for a Strong password:")
print(f"{error1}\n{error2}")
while True:
    password = input("\nEnter your password: ")
    #The password should be 8 characters long
    # it should have a uppercase letter and it should be alphanumeric
    if len(password) >= 8 and any(char.isupper() for char in password) and any(char.isdecimal() for char in password):
        print("\nCongrats!, it's a strong password")
        print()
        break
    else:
        print(error1,error2, sep = "\n")
        print()

The any() function was a side-discovery here — found it while looking for a clean way to scan every character in a string. Those little finds while building are my favourite part of self-learning.

Day 6 & 7 — The Project: A Text-Based Adventure Game

The end-of-week project was the most fun I've had coding so far. I built a full game called The Abandoned House:

🗺️ Three rooms to explore (bedroom, kitchen, living room)
🎒 An inventory system — flashlight in the bedroom, key in the kitchen
👹 A random beast that kills you if it appears in your room
🏆 A real win condition — collect both items, reach the living room
🔁 A retry option when you die

Here's the full code:

import random
#set gamestate
game_state = True
#player location
player_location = "bedroom"
#Adding tools
tools = {"bedroom": "flashlight", "kitchen": "key"}
inventory = []
#Adding locations
locations = ["bedroom", "kitchen", "living room"]

def main():
    start_game()
    if not game_state:
        return
    print_story()
    while game_state:
        #location printing
        #check for items 
        #pickup if there
        # where to?
        if not game_state:
            break
        print_location()
        move_player()
        if not game_state:
            break
        game_end()

def start_game():
    global game_state
    game_menu = input("\n\tThe Abondoned House\n\n\tStart\n\tQuit\n\n").title()
    if game_menu == "Quit":
        print("\nQuitting....")
        game_state = False
    else:
        print("\nLoading...")

def print_story():
    print('''\nIt's midnight, I am driving on a narrow road in the middle of a forest; Oh shit
I just hit something. (opens the car door and steps out looks behind, but sees
no one confused as he turns back to get into his car) Ahhh..... (Get hits by 
someone in the head and becomes unconcious After a while...) Where am I??(Wakes up in a room)
, I have to get out of here!")''')
    return

def print_location():
    global player_location
    print(f"\nI'm in the {player_location}")

def move_player():
    global player_location
    while True:
        go = input("\nWhere would you like to go?\nbedroom\nkitchen\nliving room\n\n ")
        if player_location == go:
            print(f"Already in {player_location}")
        else:
            player_location = go
            print_location()
            beast()
            if not game_state:
                break
            check_up()
            break

def beast():
    global player_location
    global game_state
    beast_location = random.choice(locations)
    if beast_location == player_location:
        print("you are Dead")
        retry_input = input("Would you like to play again?(yes/no) ")
        if retry_input == "yes":
            move_player()
        else:
            game_state = False
    else:
        print("growlssss.........The beast is nearby")

def check_up():
    global player_location
    if player_location in tools:
        pick_up()
    else:
        print("There is nothing useful here!")

def pick_up():
    pick = input(f"Would you like to pickup {tools[player_location]}?(yes/no)? ")
    if pick == "yes":
        print("Picking up...")
        inventory.append(tools.pop(player_location))
        print(f"inventory updated: {inventory}")
    else:
        game_end()

def game_end():
    global player_location
    global game_state
    if "flashlight" in inventory and "key" in inventory and player_location == "living room":
        print("I am finally out of this house!")
        game_state = False
    else:
        print("I am missing one more thing!")
        move_player()

main()

The moment the win condition triggered for the first time — "I am finally out of this house!" — felt like a genuine milestone. This wasn't a tutorial I followed. I built this.

📁 What I Built This Week

Project	File	Concepts Used
Hello World + Greeter	`hello.py`	`print()`, `input()`, f-strings
String Methods Playground	`methods.py`	String methods, data types
Calculator	`calculator.py`	`input()`, `if/elif/else`, `isdecimal()`
Number Guessing Game	`guessTheNumber.py`	`while`, `random`, `match`, conditionals
Multiplication Table	`table.py`	`for` loop, nested `while`
Password Validator	`password.py`	`while`, `any()`, string methods
Text Adventure Game	`game.py`	Functions, global state, everything above

All the code is on GitHub — every file, every day:
👉 github.com/Omk4314/progress-on-python

I'm committing daily — even the messy days.

What Actually Clicked This Week

Python reads like English. I expected gibberish. I got readable logic.
Building > drilling. The calculator taught me more than ten isolated exercises ever could.
Errors are clues. Once I stopped panicking at red text, debugging became a puzzle, not a crisis.
match is underrated. I stumbled onto it and immediately liked it more than long if/elif chains.
Momentum matters. Day 1 was rough. By Day 5 I was genuinely looking forward to opening the terminal.

What I Want to Learn Next

Week 2 is going to cover:

Functions properly — I've been using them without fully understanding the mechanics
Lists and dictionaries — my adventure game needed them and I can feel the gap
Basic file I/O — so my game can actually save progress
Maybe some OOP — no promises, just curiosity

If you're also learning Python from scratch, I'd love to see what you're building. Drop it in the comments — beginner projects deserve to be seen.

See you next week. 🐍

Week 1 complete. The terminal no longer scares me. That's enough for now.

DEV Community: Om Kolhapure

Week 3: Lists, Dicts, and Why Data Structures Matter.

Day 15 — Lists Deep Dive: A Real To-Do App

Day 16 — List Comprehensions: Less Code, Same Power

Day 17 — Dictionaries: A Contact Book

Day 18 — Nested Data: An Inventory System

Day 19 — Sets & Tuples

Day 20 — The Week 3 Project: A Python Quiz App

qdata.py — The Data Layer

quiz.py — The Game Engine

📁 What I Built This Week

What Actually Clicked This Week

What I Want to Learn Next

Week 2: From Sphaghetti to Functions

Day 8 — Functions: One Job, One Function

Day 9 — Parameters & Return Values

Day 10 — Scope & Modules

Day 11 — Error Handling: try/except

Day 12 — Built-in Libraries: random, datetime, sys

Day 13 — The Week 2 Project: A Password Manager

📁 What I Built This Week

What Actually Clicked This Week

What I Want to Learn Next

What I learned in Week 1

What I Learned in Week 1 of Python — And Why I'm Already Hooked

Day 1 — Hello, World (and Hello, print())

Day 2 — String Methods and the Beauty of Built-ins

Day 3 — User Input + My First Real Program

Day 4 — Conditionals and a Game With Difficulty Levels

Day 5 — Loops: Two Programs, One Concept

Multiplication Table Generator

Password Validator

Day 6 & 7 — The Project: A Text-Based Adventure Game

📁 What I Built This Week

What Actually Clicked This Week

What I Want to Learn Next

`qdata.py` — The Data Layer

`quiz.py` — The Game Engine

Day 11 — Error Handling: `try/except`

Day 12 — Built-in Libraries: `random`, `datetime`, `sys`

Day 1 — Hello, World (and Hello, `print()`)