DEV Community: Palak Hirave

Day 32 : Email SMTP

Palak Hirave — Sun, 04 Oct 2026 11:01:37 +0000

Today I learnt how to send emails using Python. Overall, it was a fun little project. However, since I needed two dummy emails and creating emails nowadays is such a pain, I downloaded the aiosmtpd module to reroute the emails back to myself. This allowed me to do it without needing to cross the internet and without needing to haggle for two legitimate emails that I would anyway end up deleting. All of this is mainly due to the fact that the '100 Days of Code' bootcamp that I am following was created in 2020. As much as the creator has updated it, some parts do remain unconventional if I were to do exactly what the video says.

Also, I won't post any of my programs here from now on, as I have created a GitHub account and will not post all of my projects there.

As I was going through this challenge, one thought kept on popping up-should I continue it? With AI writing code and giving us answers in seconds, learning how to manually write code isn't of much use now and even if I run into an error, some digging with AI will get me out of it most of the time. Of course this may not be true for larger, more complex projects but for my level that most definitely is the case. I even used Google's AI Overview to figure out how to bypass making two new emails in order to do this project, which is what caused me to seriously think about this. I am the type to finish whatever they started, but in this case while doing this challenge is really useful I also want to get a move on with learning more about cybersecurity and ethical hacking, as that is the direction I am leaning more towards. So now I am conflicted whether or not I should finish this, as my time could be spent progressing in the field I want to but I also hate leaving things unfinished. So, what do you think?

Also, the challenge I am following is the '100 Days of Code™: The Complete Python Pro Bootcamp' on Udemy created by Angela Yu.

Oh! One more thing, I've switched from Linktree to bio.site due to there being too many adds on the free tier. Here is my new bio.

NOTE - From now on I will not post blog updates on dev.to, rather I'll directly post the projects on my GitHub Repository which can be found here.

Day 31 : Flash Card Project

Palak Hirave — Sat, 12 Sep 2026 12:31:47 +0000

Today, I built a basic flash card project.

Flash Card Project

from tkinter import *
import pandas
import random

BACKGROUND_COLOR = "#B1DDC6"
window = Tk()
window.title("Flash Card Project")
window.config(padx=50, pady=50, bg=BACKGROUND_COLOR)

canvas = Canvas(width=800, height=526, bg=BACKGROUND_COLOR, highlightthickness=0)

right_img = PhotoImage(file="./images/right.png")
wrong_img = PhotoImage(file="./images/wrong.png")
card_back_img = PhotoImage(file="./images/card_back.png")
card_front_img = PhotoImage(file="./images/card_front.png")

screen = canvas.create_image(400, 263, image=card_front_img)
canvas.grid(column=0, row=0, columnspan=2)

to_learn = {}
try:
    data = pandas.read_csv("words_to_learn.csv")
except FileNotFoundError:
    org_data = pandas.read_csv("./data/french_words.csv")
    to_learn = org_data.to_dict(orient="records")
else:
    to_learn = data.to_dict(orient="records")

def next_card():
    global random_word, flip_timer
    window.after_cancel(flip_timer)
    random_word = random.choice(to_learn)
    canvas.itemconfig(screen, image=card_front_img)
    canvas.itemconfig(language_text, text="French")
    canvas.itemconfig(vocab_text, text=random_word["French"])
    flip_timer = window.after(3000, func=flip_card)

words_to_learn = data.to_csv("words_to_learn.csv", index=False)

def rid_value():
    to_learn.remove(random_word)
    list = pandas.DataFrame(to_learn)
    list.to_csv("words_to_learn.csv", index=False)
    next_card()

def flip_card():
    canvas.itemconfig(screen, image=card_back_img)
    canvas.itemconfig(language_text, text="English")
    canvas.itemconfig(vocab_text, text=random_word["English"])

flip_timer = window.after(3000, func=flip_card)

right_button = Button(image=right_img, highlightthickness=0, bd=0, relief="flat",
                      bg=BACKGROUND_COLOR, activebackground=BACKGROUND_COLOR, command=rid_value)
right_button.grid(row=2, column=0)
wrong_button = Button(image=wrong_img, highlightthickness=0, bd=0, relief="flat",
                      bg=BACKGROUND_COLOR, activebackground=BACKGROUND_COLOR, command=next_card)
wrong_button.grid(row=2, column=1)

language_text = canvas.create_text(400, 150, text="Title", font=("Arial", 40, "italic"), fill="black")
vocab_text = canvas.create_text(400, 263, text="word", font=("Arial", 60, "bold"), fill="black")

next_card()

window.mainloop()

Day 30 : Error Handling

Palak Hirave — Wed, 09 Sep 2026 11:49:40 +0000

Today I leant about error handling and what JSON files are. And as for my project, I updated two previous projects, the NATO Alphabet with thr try:, except:, else:, and finally: commands and the password manager but with JSON files rather than text ones. I also added an additional feature that allows you to search for the details of the website you enter into the entry. I also plan to start a GitHub account soon for my upcoming projects, as they are going to get more and more advanced and it is better to post them in GitHub rather than copy paste them here. I will still make posts talking about the projects though.

NATO Alphabet

import csv
#TODO 1. Create a dictionary using dictionary comprehension:
with open("nato_phonetic_alphabet.csv") as file:
    reader = csv.reader(file)
    alphabet = {row[0]: row[1] for row in reader if row[0] != "letter"}
    print(alphabet)

#TODO 2. Create a list of the phonetic code words from a word that the user inputs.
name = input("Enter your name: ")
on = True
while on:
    try:
        broken_name = [letter.upper() for letter in name]
        words = [alphabet[assigned_letter] for assigned_letter in broken_name]
    except KeyError:
        print("Only letters in the alphabet are accepted.")
    else:
        print("The NATO phonetic words for you name is: \n", words)
    finally:
        run = str(input("Would you like to continue? (y/n)")).lower()
        if run == "y":
            name = input("Enter your name: ")
        else:
            on = False

Password Manager

from  tkinter import *
from tkinter import messagebox
from random import choice, randint, shuffle
import pyperclip
import json
#---------------------------- PASSWORD GENERATOR ------------------------------- #
def generate_password():
    letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
    numbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
    symbols = ['!', '#', '$', '%', '&', '(', ')', '*', '+']

    password_letters = [choice(letters) for _ in range(randint(8, 10))]
    password_symbols = [choice(symbols) for _ in range(randint(2, 4))]
    password_numbers = [choice(numbers) for _ in range(randint(2, 4))]

    password_list = password_letters + password_symbols + password_numbers

    shuffle(password_list)

    password = "".join(password_list)
    password_entry.insert(0, password)
    pyperclip.copy(password)
# ---------------------------- SAVE PASSWORD ------------------------------- #
def save_data():
    website = website_entry.get()
    email = email_entry.get()
    password = password_entry.get()
    dict = {website: {"email": email, "password": password}}

    if len(website) == 0 or len(email) == 0 or len(password) == 0:
        messagebox.showerror("Error", "Please fill in all fields")
    else:
        is_ok = messagebox.askokcancel(title=website, message=f"Here are the details: \nPassword: {password}"
                                                      f"\nEmail: {email} \n Is it okay to save?")
        if is_ok:
            try:
                with open("data.json", "r") as d_file:
                    dictt = json.load(d_file)
            except FileNotFoundError:
                with open("data.json", "w") as file:
                    json.dump(dict, file, indent=4)
            else:
                dictt.update(dict)
                with open("data.json", "w") as file:
                    json.dump(dictt, file, indent=4)
            finally:
                    website_entry.delete(0, END)
                    password_entry.delete(0, END)

def find_password():
    website=str(website_entry.get())
    print(website)
    with open("data.json", "r") as d_file:
        data = json.load(d_file)
        if website in data:
            messagebox.showinfo(f"Search: {website}", f"email : {data[website]["email"]} \n password : {data[website]["password"]}")
        else:
            messagebox.showerror("Website Error", "This website is currently not in the list.")

# ---------------------------- UI SETUP ------------------------------- #
window = Tk()
window.title("Password Manager")
window.minsize(500, 250)
window.config(padx=30, pady=30)

canvas = Canvas(width=200, height=200)
logo = PhotoImage(file="logo.png")

canvas.create_image(100, 100, image=logo)
canvas.grid(column=1, row=0)

website_label = Label(window, text="Website:")
website_label.grid(column=0, row=1)
website_entry = Entry(width=50)
website_entry.focus()
website_entry.grid(column=1,row=1, columnspan=2)
website_search = Button(text="           Search           ", command=find_password)
website_search.grid(column=1, row=1, padx=5,sticky="e")

email_label = Label(window, text="Email/Username:")
email_label.grid(column=0, row=2)
email_entry = Entry(width=50)
email_entry.insert(0,"example@gmail.com")
email_entry.grid(column=1,row=2, columnspan=2)

password_label = Label(window, text="Password:")
password_label.grid(column=0, row=3)
password_entry = Entry(width=50)
password_entry.grid(column=1,row=3, padx=5, sticky="w")
password_button = Button(text="Generate Password", command=generate_password)
password_button.grid(column=1, row=3, padx=5,sticky="e")

add_button = Button(text="Add", width=42, command=save_data)
add_button.grid(column=1, row=4, columnspan=2)

window.mainloop()

Day 29 : Password Manager

Palak Hirave — Sun, 06 Sep 2026 16:15:24 +0000

This is a local version of Google's Password Manager, in which the user has to manually input all of their passwords, which then gets saved in a text file to view later.

Screenshots

Main screen, the email field is pre-set with your email however you can change it

Confirmation popup

Error message if you try to add a new entry but have blank fields

All entires get saved into a text file

Program

from  tkinter import *
from tkinter import messagebox
from random import choice, randint, shuffle
import pyperclip
#---------------------------- PASSWORD GENERATOR ------------------------------- #
def generate_password():
    letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
    numbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
    symbols = ['!', '#', '$', '%', '&', '(', ')', '*', '+']

    password_letters = [choice(letters) for _ in range(randint(8, 10))]
    password_symbols = [choice(symbols) for _ in range(randint(2, 4))]
    password_numbers = [choice(numbers) for _ in range(randint(2, 4))]

    password_list = password_letters + password_symbols + password_numbers

    shuffle(password_list)

    password = "".join(password_list)
    password_entry.insert(0, password)
    pyperclip.copy(password)
# ---------------------------- SAVE PASSWORD ------------------------------- #
def save_data():
    website = website_entry.get()
    email = email_entry.get()
    password = password_entry.get()

    if len(website) == 0 or len(email) == 0 or len(password) == 0:
        messagebox.showerror("Error", "Please fill in all fields")
    else:
        is_ok = messagebox.askokcancel(title=website, message=f"Here are the details: \nPassword: {password}"
                                                      f"\nEmail: {email} \n Is it okay to save?")
        if is_ok:
            with open("data.txt", "a") as file:
                file.write(f"Website: {website} | Email: {email} | Password: {password}\n")
                website_entry.delete(0, END)
                password_entry.delete(0, END)

# ---------------------------- UI SETUP ------------------------------- #
window = Tk()
window.title("Password Manager")
window.minsize(500, 250)
window.config(padx=30, pady=30)

canvas = Canvas(width=200, height=200)
logo = PhotoImage(file="logo.png")

canvas.create_image(100, 100, image=logo)
canvas.grid(column=1, row=0)

website_label = Label(window, text="Website:")
website_label.grid(column=0, row=1)
website_entry = Entry(width=50)
website_entry.focus()
website_entry.grid(column=1,row=1, columnspan=2)

email_label = Label(window, text="Email/Username:")
email_label.grid(column=0, row=2)
email_entry = Entry(width=50)
email_entry.insert(0,"example@gmail.com")
email_entry.grid(column=1,row=2, columnspan=2)

password_label = Label(window, text="Password:")
password_label.grid(column=0, row=3)
password_entry = Entry(width=50)
password_entry.grid(column=1,row=3, padx=5, sticky="w")
password_button = Button(text="Generate Password", command=generate_password)
password_button.grid(column=1, row=3, padx=5,sticky="e")

add_button = Button(text="Add", width=42, command=save_data)
add_button.grid(column=1, row=4, columnspan=2)

window.mainloop()

Day 28 : Pomodoro Timer

Palak Hirave — Mon, 31 Aug 2026 15:11:48 +0000

Many of you may have heard of the famous time management technique - the Pomodoro Timer. This is where you set a 'work' timer for 25 minutes and then a 'break' timer for 5 minutes. You repeat this set 4 times before taking a longer 15 minute break. Today, I decided to build that by combining my knowledge about GUIs and the Tkinter module alongside learning about the canvas widget and how dynamic typing in Python works. Overall, this project was straightforward in its steps though I did struggle a bit with figuring out how to smoothly run the timers. As of now, the timers are of 25 mins, with 5 min breaks and then 15 min breaks between the set, but I plan on improving this so that the user can specify their session breaks(with the min requirement of the amount of time being the standard pomodoro, and adding constraints so they don't abuse the break time).

While I cannot upload videos directly into dev.to posts, below are some screenshots of how the final product looks. My code is posted at the bottom as usual.

Screenshots

Work Timer Screen

Short Break Screen

Long Break Screen, keeps on adding check marks after each round of work + break

Program (main.py)

from tkinter import *
import math
# ---------------------------- CONSTANTS ------------------------------- #
PINK = "#e2979c"
RED = "#e7305b"
GREEN = "#9bdeac"
YELLOW = "#f7f5dd"
FONT_NAME = "Courier"
WORK_MIN = 25
SHORT_BREAK_MIN = 5
LONG_BREAK_MIN = 15
REPS = 0
timer = None

# ---------------------------- TIMER RESET ------------------------------- # 
def reset_screen():
    global REPS
    REPS = 0
    canvas.itemconfig(title_text, text="Timer", fill=GREEN)
    canvas.itemconfig(timer_text, text="00:00")
    check_marks.config(text=" ")

def reset_timer():
    window.after_cancel(timer)
    reset_screen()

# ---------------------------- TIMER MECHANISM ------------------------------- # 
def timer_time():
    global REPS
    REPS += 1
    if REPS % 8 == 0:
        countdown(LONG_BREAK_MIN * 60)
        canvas.itemconfig(title_text, text="Break", fill=RED)
    elif REPS % 2 == 0:
        countdown(SHORT_BREAK_MIN * 60)
        canvas.itemconfig(title_text, text="Break", fill=PINK)
    else:
        countdown(WORK_MIN * 60)
        canvas.itemconfig(title_text, text="Work", fill=GREEN)

# ---------------------------- COUNTDOWN MECHANISM ------------------------------- # 
def countdown(count):
    global timer
    count_mins = math.floor(count / 60)
    count_secs = count % 60
    if count_secs < 10:
        count_secs = "0" + str(count_secs)

    canvas.itemconfig(timer_text, text=f"{count_mins}:{count_secs}")
    if count > 0:
        timer = window.after(1000, countdown, count - 1)
    else:
        timer_time()
        checks = ""
        for rep in range(math.floor(REPS/2)):
            checks += "✔"
            check_marks.config(text=checks)

# ---------------------------- UI SETUP ------------------------------- #
window = Tk()
window.title("Pomodoro Timer : Get Work Done")
window.config(padx=100, pady=25, bg = YELLOW)

canvas = Canvas(width=200, height=350, bg=YELLOW, highlightthickness=0)
tomato = PhotoImage(file="tomato.png")

canvas.create_image(100, 180, image=tomato)
canvas.grid(row=1, column=2)

timer_text = canvas.create_text(100, 190, text="00:00", fill="white", font=(FONT_NAME, 35, "bold"))
canvas.grid(row=2, column=2)

title_text = canvas.create_text(100, 30,text="Timer", fill=GREEN, font=(FONT_NAME, 35, "bold"))
canvas.grid(row=2, column=2)

start_button = Button(text = "Start", command=timer_time)
start_button.grid(row=3, column=1)
restart_button = Button(text = "Restart", command=reset_timer)
restart_button.grid(row=3, column=3)

check_marks = Label(text="", font=(FONT_NAME, 10), fg=GREEN, bg=YELLOW)
check_marks.grid(row=3, column=2)


window.mainloop()

Day 27 of 100

Palak Hirave — Wed, 19 Aug 2026 14:27:28 +0000

Today I learnt about the Tkinter module and what args and kwargs are. It has got me thinking about what sort of games I can make with it. Below are the notes, and the final project is at the very bottom.

Notes

notes.py
for learning about args and kwargs

# Multiple positional arguments
def add(*args):
    total = 0
    for n in args:
        total += n
    print(total)

add(3,56,78,9,78)

# Multiple keyword arguments
# Optional parameters

def calculate(n, **kwargs):
    print(kwargs)
    n += kwargs["add"]
    n -= kwargs["sub"]
    n *= kwargs["mul"]
    n /= kwargs["div"]

calculate(3, add = 5)

class Drawing:
    def __init__(self, **kw):
        self.colour = kw.get("colour")
        self.width = kw.get("width")
        self.height = kw.get("height")

tkinter_notes.py
self-explanatory

from tkinter import *

print("DOCUMENTATION - https://www.tcl-lang.org/man/tcl8.6/TkCmd/contents.htm")

window = Tk()
window.title("My first GUI Program")
window.minsize(400, 300)
window.config(padx = 10, pady = 10)

# Label
my_label = Label(text="This is a label.")
my_label.pack(side="left")

# Update properties of previous component (any of these 2 methods)
my_label["text"] = "New text."
my_label.config(text = "New text.")
my_label.config(padx = 15, pady = 15)

# Entry
input = Entry(width = 20)
input.pack(side = "right")

# Button
def button_clicked():
    answer = input.get()
    my_label.config(text = str(answer))

button = Button(text = "A button.", command = button_clicked)
button.pack()

window.mainloop()

# pack() is straightforward to use, you can leave it at default, left, right or bottom,
# but it is very hard to precisely position something
# with place() you can add the x= and y= parameters, but it is sometimes too specific, and
# you need to work out the position in your head
# so, with gird() you can specify the row = and column =
# however, this is relative to the other entities positions on the display
# you cannot mix grid() and pack() in the same program

Tkinter_Widgets.py
notes provided by the course

from tkinter import *

#Creating a new window and configurations
window = Tk()
window.title("Widget Examples")
window.minsize(width=500, height=500)

#Labels
label = Label(text="This is old text")
label.config(text="This is new text")
label.pack()

#Buttons
def action():
    print("Do something")

#calls action() when pressed
button = Button(text="Click Me", command=action)
button.pack()

#Entries
entry = Entry(width=30)
#Add some text to begin with
entry.insert(END, string="Some text to begin with.")
#Gets text in entry
print(entry.get())
entry.pack()

#Text
text = Text(height=5, width=30)
#Puts cursor in textbox.
text.focus()
#Adds some text to begin with.
text.insert(END, "Example of multi-line text entry.")
#Get's current value in textbox at line 1, character 0
print(text.get("1.0", END))
text.pack()

#Spinbox
def spinbox_used():
    #gets the current value in spinbox.
    print(spinbox.get())
spinbox = Spinbox(from_=0, to=10, width=5, command=spinbox_used)
spinbox.pack()

#Scale
#Called with current scale value.
def scale_used(value):
    print(value)
scale = Scale(from_=0, to=100, command=scale_used)
scale.pack()

#Checkbutton
def checkbutton_used():
    #Prints 1 if On button checked, otherwise 0.
    print(checked_state.get())
#variable to hold on to checked state, 0 is off, 1 is on.
checked_state = IntVar()
checkbutton = Checkbutton(text="Is On?", variable=checked_state, command=checkbutton_used)
checked_state.get()
checkbutton.pack()

#Radiobutton
def radio_used():
    print(radio_state.get())
#Variable to hold on to which radio button value is checked.
radio_state = IntVar()
radiobutton1 = Radiobutton(text="Option1", value=1, variable=radio_state, command=radio_used)
radiobutton2 = Radiobutton(text="Option2", value=2, variable=radio_state, command=radio_used)
radiobutton1.pack()
radiobutton2.pack()


#Listbox
def listbox_used(event):
    # Gets current selection from listbox
    print(listbox.get(listbox.curselection()))

listbox = Listbox(height=4)
fruits = ["Apple", "Pear", "Orange", "Banana"]
for item in fruits:
    listbox.insert(fruits.index(item), item)
listbox.bind("<<ListboxSelect>>", listbox_used)
listbox.pack()
window.mainloop()

Final Project (Miles to Kilometer Conversion)

from tkinter import *
window = Tk()
window.title("Miles to Kilometers")
window.minsize(300, 100)
window.config(padx = 5, pady = 5)

# TODO : define a function to convert miles to kilometers rounded to the nearest .1
def conversion(answer):
    kilometers = float(answer) * 1.60934
    kilometers = round(kilometers, 1)
    return kilometers

# TODO : define a function to get the user's input and display conversion
input = Entry(width = 20)
input.grid(row=0, column=0)

label = Label(text="Miles is equals to")
label.grid(row=0, column=1)

answer_label = Label(text="0")
answer_label.grid(row=1, column=0)

final_label= Label(text="Km")
final_label.grid(row=1, column=1)

def button_clicked():
    answer = input.get()
    answer_label.config(text = str(conversion(answer)))

button = Button(text = "Calculate", command = button_clicked)
button.grid(row=2, column=2)

window.mainloop()

Day 26 of 100

Palak Hirave — Wed, 12 Aug 2026 10:42:17 +0000

I looked though how to do list and dictionary comprehensions as well as making a small project based off of it.

notes.py

import random
import pandas

# List Comprehension
# new_list = [new_item for item in list]

numbers = [1, 2, 3, 4, 5, 6]
numbers_plus_one = [n + 1 for n in numbers]
print(numbers_plus_one)

name = "Palak"
letters = [letter for letter in name]
print(letters)

numbers = [n for n in range(1,6)]
print(numbers)

# Conditional List Comprehension
# new_list = [new_item for item in list if test]

names = ["Alex", "Beth", "Jane", "Roger", "Freddie", "Max", "Maximus", "Tyler"]
short_names = [name for name in names if len(name) <= 4]
print(short_names)

uppercase_names = [name.upper() for name in short_names if len(name) < 5]
print(uppercase_names)

print("----------------------------------------------------")

# Dictionary Comprehension
# new_dict = {new_key:new_value for item in list}
# new_dict = {new_key:new_value for (key,value) in dict.items()}

names = ["Alex", "Beth", "Jane", "Roger", "Freddie", "Max", "Maximus", "Tyler"]
random_scores = {students:random.randint(1,101) for students in names}
print(random_scores)

passed_students = {students:random_scores[students] for students in names if random_scores[students] >= 60}
# OR passed_students = {students:score for (students,score) in random_scores.items() if score >= 60}
print(passed_students)

# Turn dict into DataFrame
colours = {"Red" : ["Bright", "Dark"],
            "Blue" : ["Sky", "Deep"]}

students_dataframe = pandas.DataFrame(colours)
print(students_dataframe)

# Loop through a data frame
for (key, value) in students_dataframe.items():
    print(value)

# Loop through rows in a dataframe
for (index, row) in students_dataframe.iterrows():
    print(row)

NATO Alphabet Mini-Project (main.py)

import csv

#TODO 1. Create a dictionary using dictionary comprehension:
with open("nato_phonetic_alphabet.csv") as file:
    reader = csv.reader(file)
    alphabet = {row[0]: row[1] for row in reader if row[0] != "letter"}

#TODO 2. Create a list of the phonetic code words from a word that the user inputs.
name = input("Enter your name: ")
broken_name = [letter.upper() for letter in name ]
words = [alphabet[assigned_letter] for assigned_letter in broken_name]
print("The NATO phonetic words for you name is: \n", words)

nato_phonetic_alphabet.csv

letter,code
A,Alfa
B,Bravo
C,Charlie
D,Delta
E,Echo
F,Foxtrot
G,Golf
H,Hotel
I,India
J,Juliet
K,Kilo
L,Lima
M,Mike
N,November
O,Oscar
P,Papa
Q,Quebec
R,Romeo
S,Sierra
T,Tango
U,Uniform
V,Victor
W,Whiskey
X,X-ray
Y,Yankee
Z,Zulu

Day 25 of 100

Palak Hirave — Sun, 09 Aug 2026 13:48:15 +0000

Whilst I had heard about the Pandas library, today I learnt how to use it. I also took some time later to just go though the 'getting started' part of the documentation(which can be found here). I took some notes and then did a project in which you have to guess all 50 of the United States. This list of various bits of code is ordered from what I did first and my final project at the bottom.

notes.py

print("------------------------------------------------------")

import csv
# Reading a file and collecting data from one of its
#   columns and converting it to an integer
with open("weather_data.csv") as data_file:
    data = csv.reader(data_file)
    temp = []
    for row in data:
        if row == ['day', 'temp', 'condition']:
            pass
        else:
            degree = int(row[1])
            temp.append(degree)
    print(temp)

print("------------------------------------------------------")

import pandas as pd
# With Pandas
data = pd.read_csv('weather_data.csv')
print(data["temp"])

print("------------------------------------------------------")

# Turns DataFrame to dictionary
data_dict = data.to_dict()
print(data_dict)

# Turns Series to list
temp_list = data["temp"].to_list()
print(temp_list)

print("------------------------------------------------------")

average = sum(temp_list) / len(temp_list)
# OR
average = data["temp"].mean()

print(data["temp"].max())

print("------------------------------------------------------")

# Get data in columns
print(data["condition"])
print(data.condition) #Behind the scenes, pandas
                    # converts each of the columns into attributes
# Get data in rows
print(data[data.day == "Monday"])
print(data[data.temp == data.temp.max()])

monday = data[data.day == "Monday"]
fahrenheit = monday["temp"] * 1.8 + 32
print(fahrenheit)

print("------------------------------------------------------")

# Create DataFrame from scratch
newdata_dict = {"names" : ["John", "Rebecca", "Myles", "Styles", "Anthony"],
                "test scores" : [24, 99, 57, 78, 80]}

data = pd.DataFrame(newdata_dict)
data.to_csv("new_data.csv", index=False)

weather_data.csv

day,temp,condition
Monday,12,Sunny
Tuesday,14,Rain
Wednesday,15,Rain
Thursday,14,Cloudy
Friday,21,Sunny
Saturday,22,Sunny
Sunday,24,Sunny

new_data.csv (created once notes.py runs)

names,test scores
John,24
Rebecca,99
Myles,57
Styles,78
Anthony,80

Squirrels!

The squirrel data for this project can be found here.

import pandas as pd
# TODO : take the Primary Fur Color column and make a
#  new .csv file that contains the three colours and
#  how many squirrels are in each one

black = 0
gray = 0
cinnamon = 0

data = pd.read_csv("squirrel_data.csv")
for color in data["Primary Fur Color"] :
    if color == "Black" :
        black += 1
    elif color == "Gray" :
        gray += 1
    else:
        cinnamon += 1

small_squirrel_data = {"Colour" : ["Black", "Gray", "Cinnamon"],
                       "Count" : [black, gray, cinnamon],}
data = pd.DataFrame(small_squirrel_data)
data.to_csv("small_squirrel_data.csv", index=False)

Output CSV file (small_squirrel_data.csv)

Colour,Count
Black,103
Gray,2473
Cinnamon,447

Main Project - Guess the USA's States

main.py

import pandas as pd
import turtle
import time

screen = turtle.Screen()
screen.title("U.S.A State Game")
image = "blank_states_img.gif"
screen.addshape(image)
screen.setup(height=500,width=730)
screen.bgpic("blank_states_img.gif")
turtle.shape(image)

# TODO : Get x and y values for all states on the image
# def mouse_click_coord(x,y):
#     print(x,y)
#
# turtle.onscreenclick(mouse_click_coord)
# turtle.mainloop()

game_on = True
states_guessed = 0
correct_guess = ""
guessed_states = []
pen = turtle.Turtle()
pen.penup()
pen.hideturtle()
pen.speed(0)

while game_on:
    answer_state = screen.textinput(title="Guess a state",
                                    prompt=f"{states_guessed}/50 states guessed", )

    states_list = pd.read_csv("50_states.csv")

    for states in states_list.state:
        if states == answer_state.title():
            correct_guess = answer_state.title()

            if correct_guess not in guessed_states:
                states_guessed += 1
                guessed_states.append(correct_guess)
                row_list = states_list[states_list.state == correct_guess]
                row_list = row_list.to_dict()
                xcor = list(row_list['x'].values())[0]
                ycor = list(row_list['y'].values())[0]
                pen.goto(x = xcor, y = ycor)
                pen.write(correct_guess, align="right", font=("Courier", 7, "bold"))

    if states_guessed == 50:
        screen.textinput("Finished", "You have guessed all the states!")
        time.sleep(1)
        game_on = False

screen.exitonclick()

50_states.csv
Note - the coordinates may not be exact for everyone, their a bit off for me as well but I can't be asked to individually change them all.

state,x,y
Alabama,139,-77
Alaska,-204,-170
Arizona,-203,-40
Arkansas,57,-53
California,-297,13
Colorado,-112,20
Connecticut,297,96
Delaware,275,42
Florida,220,-145
Georgia,182,-75
Hawaii,-317,-143
Idaho,-216,122
Illinois,95,37
Indiana,133,39
Iowa,38,65
Kansas,-17,5
Kentucky,149,1
Louisiana,59,-114
Maine,319,164
Maryland,288,27
Massachusetts,312,112
Michigan,148,101
Minnesota,23,135
Mississippi,94,-78
Missouri,49,6
Montana,-141,150
Nebraska,-61,66
Nevada,-257,56
New Hampshire,302,127
New Jersey,282,65
New Mexico,-128,-43
New York,236,104
North Carolina,239,-22
North Dakota,-44,158
Ohio,176,52
Oklahoma,-8,-41
Oregon,-278,138
Pennsylvania,238,72
Rhode Island,318,94
South Carolina,218,-51
South Dakota,-44,109
Tennessee,131,-34
Texas,-38,-106
Utah,-189,34
Vermont,282,154
Virginia,234,12
Washington,-257,193
West Virginia,200,20
Wisconsin,83,113
Wyoming,-134,90

Day 24 of 100

Palak Hirave — Sat, 08 Aug 2026 12:43:34 +0000

Today I learnt all about files, paths and directories. I learnt what a relative and absolute file path is as well as how to use both in Pycharm alongside reading and writing files. Rather than doing a singular main project I did multiple small ones, including upgrading my Snake game to have a high score that stays every time you load the game.

This is one of the mini-projects that I did -

with open("C:/Users/hirav/Desktop/Python Projects/Mail Merge Project/Input/Names/invited_names.txt", "r") as file:
    invited_names = file.read().splitlines()

with open("C:/Users/hirav/Desktop/Python Projects/Mail Merge Project/Input/Letters/starting_letter.txt") as letter:
    base_letter = letter.read()

for name in invited_names:
    with open(f"C:/Users/hirav/Desktop/Python Projects/Mail Merge Project/Output/ReadyToSend/letter.to.{name}.txt", "w") as email:
        email.write(base_letter.replace("[name]", name))

Day 23 of 100

Palak Hirave — Fri, 24 Jul 2026 10:33:11 +0000

Today I made the capstone project for the beginners section of my 100 days of python challenge. It is similar to the Crossy Roads game. There is a turtle which has to make it to the end of the screen before any of the colourful blocks(which move from the right to left) hit it. Each time it crosses the northern boundary(the turtle starts in the south and heads upwards) it returns to its original position for the next level, except this time the blocks are moving faster.

Overall I had a great time building this project. After a quick overview into how the game was supposed to work I found that it was quite straightforward and didn't need much problem solving. I flew though creating the turtle, scoreboard and game over screen but got a little stuck on how to make so many blocks and how to detect if a block has collided with the turtle. In the end, it worked out quite nicely.

When it comes to the actual program, I should have cleaned up the code a bit but was not quite sure how to. Mostly on the car_manager part(The cars are the blocks). I could have turned all of the workings for the blocks/cars I did in the while loop into separate functions in the CarManager class and then simply called them but I wasn't quite sure how to. That is definitely something to improve/look into next time. I am quite happy to finally be in the intermediate territory of python programming.

Here's the code -

main.py

import time
from turtle import Screen
from player import Player
from car_manager import CarManager
from scoreboard import Scoreboard

screen = Screen()
screen.setup(width=600, height=600)
screen.tracer(0)
screen.title("Turtle Crossing Game")

player = Player()
scoreboard = Scoreboard()
cars = []
car = CarManager()

cars.append(car)

loop_count = 0
MOVE_SEGMENT = 5

game_is_on = True
while game_is_on:
    time.sleep(0.1)
    screen.update()
    for c in cars:
        c.backward(MOVE_SEGMENT)

    screen.onkey(player.move_up, "Up")
    screen.listen()

    if player.ycor() >= 280:
        scoreboard.update_score()
        player.reset_pos()
        MOVE_SEGMENT += 7

    loop_count += 1
    if loop_count == 6:
        car = CarManager()
        cars.append(car)
        loop_count = 0

    for cr in cars:
        if player.distance(cr) < 20:
            game_is_on = False

screen.tracer(1)
scoreboard.game_over()

screen.exitonclick()

player.py

from turtle import Turtle

STARTING_POSITION = (0, -280)
MOVE_DISTANCE = 10
FINISH_LINE_Y = 280

class Player(Turtle):
    def __init__(self):
        super().__init__()
        self.color("black")
        self.shape("turtle")
        self.setheading(90)
        self.penup()
        self.goto(STARTING_POSITION)


    def move_up(self):
        self.forward(MOVE_DISTANCE)

    def reset_pos(self):
        self.goto(STARTING_POSITION)

scoreboard.py

from turtle import Turtle

FONT = ("Courier New", 22, "bold")

class Scoreboard(Turtle):
    def __init__(self):
        super().__init__()
        self.color("black")
        self.penup()
        self.hideturtle()
        self.goto(-280,260)
        self.write("Score:0", font = FONT)
        self.score = 0

    def update_score(self):
        self.score += 1
        self.clear()
        self.write("Score:" + str(self.score), font = FONT)

    def game_over(self):
        self.goto(-70,-10)
        self.write("Game Over.", font=FONT)

car_manager.py

from turtle import Turtle
import random

COLORS = ["red", "orange", "yellow", "green", "blue", "purple"]
STARTING_MOVE_DISTANCE = 5
MOVE_INCREMENT = 10

class CarManager(Turtle):
    def __init__(self):
        super().__init__()
        self.color(random.choice(COLORS))
        self.shape("square")
        self.penup()
        self.shapesize(stretch_wid=1, stretch_len=2)
        self.random_y = random.randint(-250, 250)
        self.goto(300,self.random_y)

    def collision(self):
        pass

Learning Log

Palak Hirave — Fri, 24 Jul 2026 05:42:24 +0000

Hello. Here I will be listing the resources I used for learning cybersecurity and in the order I completed them. Feel free to use any of the resources for your own learning. I'll make sure to update this list as I progress.

Day 22 of 100

Palak Hirave — Wed, 22 Jul 2026 07:12:47 +0000

I'm coming back to this series after quite a long time. It's nice to get back to programming.

Today I build the Ping Pong game with a simple UI. Here's the code -

main.py

from turtle import Screen
from paddle import Paddle
from ball import Ball
from scoreboard import Scoreboard
import time

screen = Screen()
screen.setup(width=800, height=600)
screen.bgcolor("black")
screen.title("Pong")
screen.tracer(0)

r_paddle = Paddle(350,0)
l_paddle = Paddle(-350,0)
ball = Ball()
scoreboard = Scoreboard()

screen.listen()
screen.onkey(r_paddle.up, "Up")
screen.onkey(r_paddle.down, "Down")
screen.onkey(l_paddle.up, "w")
screen.onkey(l_paddle.down, "s")

game_is_on = True

while game_is_on:
    time.sleep(ball.faster)
    screen.update()
    ball.move()

    if ball.ycor() > 280 or ball.ycor() < -280:
        ball.bounce_y()

    if ball.distance(r_paddle) < 55 and ball.xcor() > 320 or ball.distance(l_paddle) < 50 and ball.xcor() < -320:
        ball.bounce_x()

    if ball.xcor() > 380:
        ball.reset_pos()
        scoreboard.l_point()

    if ball.xcor() < -380:
        ball.reset_pos()
        scoreboard.r_point()


screen.exitonclick()

ball.py

from turtle import Turtle

class Ball(Turtle):
    def __init__(self):
        super().__init__()
        self.shape("circle")
        self.color("white")
        self.penup()
        self.x_new = 10
        self.y_new = 10
        self.faster = 0.1

    def move(self):
        new_x = self.xcor() + self.x_new
        new_y = self.ycor() + self.y_new
        self.goto(new_x, new_y)

    def bounce_y(self):
        self.y_new *= -1

    def bounce_x(self):
        self.x_new *= -1
        self.faster *= 0.7

    def reset_pos(self):
        self.goto(0,0)
        self.faster = 0.1
        self.bounce_x()

paddle.py

import turtle

class Paddle(turtle.Turtle):

    def __init__(self, xcord, ycord):
        super().__init__()
        self.color("white")
        self.shape("square")
        self.shapesize(stretch_wid=5, stretch_len=1)
        self.penup()
        self.x_cord = xcord
        self.y_cord = ycord
        self.setpos(self.x_cord, self.y_cord)
        self.jump = 20

    def up(self):
        self.goto(self.x_cord, self.y_cord + self.jump)
        self.y_cord += self.jump

    def down(self):
        self.goto(self.x_cord, self.y_cord - self.jump)
        self.y_cord -= self.jump

scoreboard.py

import turtle

class Scoreboard(turtle.Turtle):
    def __init__(self):
        super().__init__()
        self.color("white")
        self.penup()
        self.hideturtle()
        self.l_score = 0
        self.r_score = 0
        self.update_score()

    def update_score(self):
        self.clear()
        self.goto(-100, 200)
        self.write(self.l_score, align="center", font=("Arial", 70, "normal"))
        self.goto(100, 200)
        self.write(self.r_score, align="center", font=("Arial", 70, "normal"))

    def l_point(self):
        self.l_score += 1
        self.update_score()

    def r_point(self):
        self.r_score += 1
        self.update_score()