Python for Engineers

Music Playlist Manager

import os

import tkinter as tk

from tkinter import filedialog, messagebox

import pygame

class MusicPlayer:

def __init__(self, root):

self.root = root

self.root.title("Music Playlist Manager 🎵")

self.root.geometry("500x400")

pygame.init()

pygame.mixer.init()

self.playlist = []

self.current_song_index = -1

self.is_paused = False

# GUI Components

self.playlist_box = tk.Listbox(root, selectmode=tk.SINGLE, bg="white", fg="black", width=60, height=15)

self.playlist_box.pack(pady=10)

btn_frame = tk.Frame(root)

btn_frame.pack()

tk.Button(btn_frame, text="Add Song", command=self.add_song).grid(row=0, column=0, padx=5)

tk.Button(btn_frame, text="Remove Song", command=self.remove_song).grid(row=0, column=1, padx=5)

tk.Button(btn_frame, text="Play", command=self.play_song).grid(row=0, column=2, padx=5)

tk.Button(btn_frame, text="Pause", command=self.pause_song).grid(row=0, column=3, padx=5)

tk.Button(btn_frame, text="Resume", command=self.resume_song).grid(row=0, column=4, padx=5)

tk.Button(btn_frame, text="Stop", command=self.stop_song).grid(row=0, column=5, padx=5)

self.current_song_label = tk.Label(root, text="Now Playing: None", fg="blue", font=("Arial", 10, "bold"))

self.current_song_label.pack(pady=10)

def add_song(self):

file_path = filedialog.askopenfilename(filetypes=[("MP3 Files", "*.mp3")])

if file_path:

self.playlist.append(file_path)

self.playlist_box.insert(tk.END, os.path.basename(file_path))

def remove_song(self):

selected_index = self.playlist_box.curselection()

if selected_index:

index = selected_index[0]

self.playlist_box.delete(index)

del self.playlist[index]

def play_song(self):

selected_index = self.playlist_box.curselection()

if selected_index:

index = selected_index[0]

self.current_song_index = index

song_path = self.playlist[index]

pygame.mixer.music.load(song_path)

pygame.mixer.music.play()

self.is_paused = False

self.current_song_label.config(text=f"Now Playing: {os.path.basename(song_path)}")

def pause_song(self):

if not self.is_paused:

pygame.mixer.music.pause()

self.is_paused = True

def resume_song(self):

if self.is_paused:

pygame.mixer.music.unpause()

self.is_paused = False

def stop_song(self):

pygame.mixer.music.stop()

self.current_song_label.config(text="Now Playing: None")

# Run the application

if __name__ == "__main__":

root = tk.Tk()

app = MusicPlayer(root)

root.mainloop()

Personal Finance Tracker

import tkinter as tk

from tkinter import ttk, messagebox

import sqlite3

import matplotlib.pyplot as plt

# Database Setup

conn = sqlite3.connect("finance_tracker.db")

cursor = conn.cursor()

cursor.execute("""

CREATE TABLE IF NOT EXISTS transactions (

id INTEGER PRIMARY KEY AUTOINCREMENT,

date TEXT,

category TEXT,

amount REAL,

type TEXT

)

""")

conn.commit()

class FinanceTracker:

def __init__(self, root):

self.root = root

self.root.title("Personal Finance Tracker 💰")

self.root.geometry("600x500")

# UI Components

tk.Label(root, text="Date (YYYY-MM-DD):").grid(row=0, column=0, padx=10, pady=5, sticky="w")

self.date_entry = tk.Entry(root, width=30)

self.date_entry.grid(row=0, column=1, padx=10, pady=5)

tk.Label(root, text="Category:").grid(row=1, column=0, padx=10, pady=5, sticky="w")

self.category_entry = tk.Entry(root, width=30)

self.category_entry.grid(row=1, column=1, padx=10, pady=5)

tk.Label(root, text="Amount:").grid(row=2, column=0, padx=10, pady=5, sticky="w")

self.amount_entry = tk.Entry(root, width=30)

self.amount_entry.grid(row=2, column=1, padx=10, pady=5)

tk.Label(root, text="Transaction Type:").grid(row=3, column=0, padx=10, pady=5, sticky="w")

self.type_var = tk.StringVar(value="Expense")

self.type_dropdown = ttk.Combobox(root, textvariable=self.type_var, values=["Expense", "Income"], width=28)

self.type_dropdown.grid(row=3, column=1, padx=10, pady=5)

self.type_dropdown.current(0)

# Buttons - Expanded Width

tk.Button(root, text="Add Transaction", command=self.add_transaction, width=20).grid(row=4, column=0, columnspan=2, pady=10)

tk.Button(root, text="Show Transactions", command=self.show_transactions, width=20).grid(row=5, column=0, columnspan=2, pady=5)

tk.Button(root, text="View Report", command=self.view_report, width=20).grid(row=6, column=0, columnspan=2, pady=5)

# Transaction List Display

self.tree = ttk.Treeview(root, columns=("ID", "Date", "Category", "Amount", "Type"), show="headings")

self.tree.heading("ID", text="ID")

self.tree.heading("Date", text="Date")

self.tree.heading("Category", text="Category")

self.tree.heading("Amount", text="Amount")

self.tree.heading("Type", text="Type")

self.tree.column("ID", width=30)

self.tree.column("Date", width=100)

self.tree.column("Category", width=100)

self.tree.column("Amount", width=80)

self.tree.column("Type", width=80)

self.tree.grid(row=7, column=0, columnspan=2, padx=10, pady=10)

def add_transaction(self):

date = self.date_entry.get()

category = self.category_entry.get()

amount = self.amount_entry.get()

trans_type = self.type_var.get()

if not date or not category or not amount or not trans_type:

messagebox.showerror("Error", "All fields are required!")

return

try:

amount = float(amount)

cursor.execute("INSERT INTO transactions (date, category, amount, type) VALUES (?, ?, ?, ?)",

(date, category, amount, trans_type))

conn.commit()

messagebox.showinfo("Success", "Transaction added successfully!")

self.clear_entries()

except ValueError:

messagebox.showerror("Error", "Amount must be a number!")

def show_transactions(self):

for item in self.tree.get_children():

self.tree.delete(item)

cursor.execute("SELECT * FROM transactions")

for row in cursor.fetchall():

self.tree.insert("", "end", values=row)

def view_report(self):

cursor.execute("SELECT category, SUM(amount) FROM transactions WHERE type='Expense' GROUP BY category")

data = cursor.fetchall()

if not data:

messagebox.showinfo("Report", "No expenses recorded.")

return

categories, amounts = zip(*data)

plt.figure(figsize=(6, 6))

plt.pie(amounts, labels=categories, autopct="%1.1f%%", startangle=140)

plt.title("Expense Breakdown")

plt.show()

def clear_entries(self):

self.date_entry.delete(0, tk.END)

self.category_entry.delete(0, tk.END)

self.amount_entry.delete(0, tk.END)

self.type_var.set("Expense")

# Run the application

if __name__ == "__main__":

root = tk.Tk()

app = FinanceTracker(root)

root.mainloop()

Real-Time Weather Dashboard

Get an API Key from OpenWeather

import tkinter as tk

from tkinter import messagebox

import requests

# OpenWeather API Key (Replace with your own key)

API_KEY = "YOUR_OPENWEATHER_API_KEY"

BASE_URL = "http://api.openweathermap.org/data/2.5/weather"

# Function to fetch weather data

def get_weather():

city = city_entry.get()

if not city:

messagebox.showerror("Error", "Please enter a city name!")

return

params = {"q": city, "appid": API_KEY, "units": "metric"}

response = requests.get(BASE_URL, params=params)

if response.status_code == 200:

data = response.json()

weather = data["weather"][0]["description"].capitalize()

temp = data["main"]["temp"]

humidity = data["main"]["humidity"]

result_label.config(text=f"🌍 City: {city}\n🌡️ Temperature: {temp}°C\n💧 Humidity: {humidity}%\n☁️ Condition: {weather}")

else:

messagebox.showerror("Error", "City not found! Please try again.")

# GUI setup

root = tk.Tk()

root.title("Real-Time Weather Dashboard")

root.geometry("400x350")

tk.Label(root, text="Enter City Name:", font=("Arial", 14)).pack(pady=10)

city_entry = tk.Entry(root, font=("Arial", 12), width=25)

city_entry.pack(pady=5)

tk.Button(root, text="Get Weather", font=("Arial", 12), command=get_weather).pack(pady=10)

result_label = tk.Label(root, text="", font=("Arial", 14), justify="left")

result_label.pack(pady=20)

# Run GUI

root.mainloop()

Online Python Compiler 💻

pip install flask

app.py

from flask import Flask, render_template, request, jsonify

import subprocess

app = Flask(__name__)

@app.route("/")

def home():

return render_template("index.html")

@app.route("/run", methods=["POST"])

def run_code():

code = request.json.get("code", "")

try:

# Run the code in a restricted subprocess

result = subprocess.run(

["python", "-c", code],

capture_output=True,

text=True,

timeout=5

)

output = result.stdout if result.stdout else result.stderr

except Exception as e:

output = str(e)

return jsonify({"output": output})

if __name__ == "__main__":

app.run(debug=True)

templates/index.html

<!DOCTYPE html>

<head>

<title>Online Python Compiler</title>

<style>

body { font-family: Arial, sans-serif; text-align: center; }

#editor { width: 80%; height: 300px; margin: auto; border: 1px solid #ddd; }

#output { white-space: pre-wrap; background: #f4f4f4; padding: 10px; margin-top: 10px; width: 80%; }

</style>

</head>

<body>

<h1>Online Python Compiler 💻</h1>

<div id="editor">print("Hello, World!")</div>

<pre id="output">Output will appear here...</pre>

var editor = ace.edit("editor");

editor.setTheme("ace/theme/monokai");

editor.session.setMode("ace/mode/python");

function runCode() {

let code = editor.getValue();

fetch("/run", {

method: "POST",

headers: { "Content-Type": "application/json" },

body: JSON.stringify({ code: code })

})

.then(response => response.json())

.then(data => document.getElementById("output").innerText = data.output);

}

</script>

</body>

</html>

Flashcard App for Learning

import tkinter as tk

import json

import random

# File to store flashcards

FLASHCARDS_FILE = "flashcards.json"

class FlashcardApp:

def __init__(self, root):

self.root = root

self.root.title("Flashcard App")

self.root.geometry("400x300")

self.flashcards = self.load_flashcards()

self.current_flashcard = {}

# UI Elements

self.label = tk.Label(root, text="Press 'Next' to start!", font=("Arial", 14), wraplength=350)

self.label.pack(pady=20)

self.flip_button = tk.Button(root, text="Flip", command=self.flip_card)

self.flip_button.pack()

self.next_button = tk.Button(root, text="Next", command=self.next_card)

self.next_button.pack()

self.add_button = tk.Button(root, text="Add Flashcard", command=self.add_flashcard)

self.add_button.pack()

def load_flashcards(self):

try:

with open(FLASHCARDS_FILE, "r") as file:

return json.load(file)

except FileNotFoundError:

return []

def save_flashcards(self):

with open(FLASHCARDS_FILE, "w") as file:

json.dump(self.flashcards, file)

def next_card(self):

if not self.flashcards:

self.label.config(text="No flashcards available. Add some!")

else:

self.current_flashcard = random.choice(self.flashcards)

self.label.config(text=f"Q: {self.current_flashcard['question']}")

def flip_card(self):

if self.current_flashcard:

self.label.config(text=f"A: {self.current_flashcard['answer']}")

def add_flashcard(self):

add_window = tk.Toplevel(self.root)

add_window.title("Add Flashcard")

add_window.geometry("300x200")

tk.Label(add_window, text="Question:").pack()

question_entry = tk.Entry(add_window, width=40)

question_entry.pack()

tk.Label(add_window, text="Answer:").pack()

answer_entry = tk.Entry(add_window, width=40)

answer_entry.pack()

def save_new_flashcard():

question = question_entry.get()

answer = answer_entry.get()

if question and answer:

self.flashcards.append({"question": question, "answer": answer})

self.save_flashcards()

add_window.destroy()

save_button = tk.Button(add_window, text="Save", command=save_new_flashcard)

save_button.pack()

# Run the app

root = tk.Tk()

app = FlashcardApp(root)

root.mainloop()

Blog Pages

Music Playlist Manager

Personal Finance Tracker

Real-Time Weather Dashboard

Online Python Compiler 💻

Flashcard App for Learning