Boost Productivity with 30 Simple Python Scripts.pdf

Boost Productivity with 30 Simple
Python Scripts
The Power of Automation

Let's be real: no one enjoys doing the same task over and over again, right? Whether it’s
renaming files, scraping data, or even scheduling meetings, these repetitive tasks can drain
your energy and waste your time. Luckily, there’s a solution—automation. And when it
comes to automation, Python is the Swiss Army knife you need.
Imagine starting your workday with all your files neatly organized, your emails sorted, and
your daily tasks already in front of you—all without lifting a finger. That’s the magic of
automation, and it’s more accessible than ever, thanks to Python. This guide will provide you
with 51 easy-to-use Python scripts that can help you automate various everyday tasks,
saving you time, effort, and (let’s be honest) a lot of frustration.
Let’s dive into the scripts, grouped by category, to help you figure out which ones will make
your life easier.
Categories of Automation
You don’t need to be a programming wizard to get started with Python automation. These
scripts are categorized based on common tasks you probably encounter every day. Whether
you’re trying to organize your digital world, manage data, or optimize your personal
productivity, there’s something here for you.
File Management
If you’ve ever looked at your desktop or downloads folder and wondered how it got so
chaotic, you’re not alone. Managing files manually takes time—time you could spend doing
something far more productive or interesting. With these Python scripts, you can bring order
to the chaos in just a few clicks.
1. Batch Renaming Files
Ever had to rename a hundred files one by one? It’s a nightmare. Batch renaming scripts
can take the pain out of this process, allowing you to rename files based on a pattern, date,
or even their contents.
import os
def batch_rename(directory, prefix):
for count, filename in enumerate(os.listdir(directory)):
new_name = f"{prefix}_{str(count)}.jpg"
os.rename(os.path.join(directory, filename), os.path.join(directory, new_name))
batch_rename("/path/to/files", "image")
2. Organizing a Messy Desktop

Your desktop is not a storage unit. This simple script can organize your desktop by moving
files into categorized folders based on their file types.
import os
import shutil
def organize_desktop():
desktop = os.path.join(os.path.expanduser("~"), "Desktop")
file_types = {
"Images": [".jpeg", ".jpg", ".png", ".gif"],
"Documents": [".pdf", ".docx", ".txt"],
"Audio": [".mp3", ".wav"],
"Videos": [".mp4", ".mov"]
}
for file in os.listdir(desktop):
file_path = os.path.join(desktop, file)
if os.path.isfile(file_path):
for folder, extensions in file_types.items():
if file.endswith(tuple(extensions)):
folder_path = os.path.join(desktop, folder)
if not os.path.exists(folder_path):
os.mkdir(folder_path)
shutil.move(file_path, folder_path)
organize_desktop()
3. Automating Backups
Backing up your important files is one of those things you know you should do but never
actually get around to. This script makes it automatic, ensuring your data is always safe.
import shutil
import time
def backup(source_folder, backup_folder):
while True:
shutil.copytree(source_folder, backup_folder, dirs_exist_ok=True)
print(f"Backup completed at {time.ctime()}")
time.sleep(86400) # Run every 24 hours
backup("/path/to/source", "/path/to/backup")
Data Processing
Whether you’re a data scientist or someone who just needs to pull together a report every
now and then, automating data-related tasks can save you hours. Python is particularly
powerful here with its extensive libraries for web scraping, data manipulation, and reporting.

4. Web Scraping for Market Research
Need to gather information on competitors or track prices? Web scraping lets you automate
these tasks, so you can get the data you need without spending hours manually copying and
pasting.
import requests
from bs4 import BeautifulSoup
def scrape_prices(url):
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
prices = soup.find_all('span', class_='price')
for price in prices:
print(price.text)
scrape_prices("https://example.com/products")
5. Automating Data Entry
Data entry is boring and error-prone. This script can read data from a file, like a CSV, and
automatically enter it into another application or database.
import csv
def automate_data_entry(csv_file):
with open(csv_file, mode='r') as file:
csv_reader = csv.reader(file)
for row in csv_reader:
# Simulate typing into a form or database
print(f"Entering data: {row}")
automate_data_entry("data.csv")
6. Dynamic Reporting with Pandas
Need to generate reports that update based on real-time data? Python’s Pandas library can
help you create dynamic reports without the hassle of manual data crunching.
import pandas as pd
def generate_report(data_file):
df = pd.read_csv(data_file)
summary = df.describe()
print(summary)
generate_report("sales_data.csv")

Communication Enhancements
Keeping up with emails, meetings, and customer inquiries can feel like a full-time job.
Thankfully, Python can help you streamline communication, so you can focus on more
important work.
7. Email Filtering and Sorting
Tired of sorting through spam and newsletters in your inbox? This script can automatically
filter and label emails based on content or sender.
import imaplib
import email
def filter_emails(username, password):
conn = imaplib.IMAP4_SSL('imap.gmail.com')
conn.login(username, password)
conn.select('inbox')
result, data = conn.search(None, 'FROM', '"newsletters@example.com"')
for num in data[0].split():
result, msg_data = conn.fetch(num, '(RFC822)')
msg = email.message_from_bytes(msg_data[0][1])
print(f"Subject: {msg['subject']}")
filter_emails('your-email@gmail.com', 'your-password')
8. Automated Meeting Scheduling
Syncing calendars and scheduling meetings back and forth is the worst. With this script, you
can automatically check availability and propose meeting times.
import datetime
def schedule_meeting(calendar, duration):
for event in calendar:
if event['status'] == 'free':
print(f"Meeting scheduled at {event['start']} for {duration} minutes")
break
calendar = [{'start': '10:00', 'end': '11:00', 'status': 'free'}, {'start': '11:00', 'end': '12:00', 'status':
'busy'}]
schedule_meeting(calendar, 30)
9. Chatbot for FAQs
Need a simple solution for answering frequently asked questions in customer support? This
chatbot script can handle basic queries, freeing up your time for more complex issues.
def chatbot(question):

faq = {
"What are your hours?": "We are open from 9 AM to 5 PM.",
"Where are you located?": "We are located at 123 Main St."
}
return faq.get(question, "I'm sorry, I don't have the answer to that.")
print(chatbot("What are your hours?"))
Task and Project Management
Managing tasks and keeping track of time can be overwhelming, especially when you’re
juggling multiple projects. Automating some of these processes can help you stay organized
and on track.
10. Daily Task Reminders
Need help remembering your priorities? This script sends a daily reminder of your tasks for
the day.
import datetime
def task_reminder(tasks):
today = datetime.date.today()
print(f"Today's date: {today}")
for task in tasks:
print(f"Reminder: {task}")
tasks = ["Complete report", "Respond to emails", "Meeting at 3 PM"]
task_reminder(tasks)
11. Automated Gantt Charts
Visualizing project timelines can be a hassle, but this script automates the creation of Gantt
charts to help you track progress effortlessly.
import matplotlib.pyplot as plt
import pandas as pd
def create_gantt_chart(data):
df = pd.DataFrame(data)
fig, ax = plt.subplots()
ax.barh(df['Task'], df['Duration'], left=df['Start'])
plt.show()
data = {'Task': ['Planning', 'Development', 'Testing'], 'Start': [1, 5, 10], 'Duration': [4, 3, 2]}
create_gantt_chart(data)
12. Time Tracking Automation

If you’re working on billable hours or just want to know where your time is going, this script
tracks how much time you spend on each task.
import time
def track_time(task):
start_time = time.time()
input(f"Press Enter to stop tracking time for {task}")
end_time = time.time()
print(f"Time spent on {task}: {end_time - start_time} seconds")
track_time("Writing article")
Development and Collaboration
For developers, automating repetitive coding tasks can save significant time. From testing to
deployment, Python can help streamline your workflow.
13. Continuous Integration Scripts
Automating testing and deployment ensures that code is always working as expected. This
script can run tests and deploy code automatically when changes are made.
import subprocess
def run_tests_and_deploy():
subprocess.run(["pytest"])
subprocess.run(["git", "push", "origin", "main"])
run_tests_and_deploy()
14. Code Quality Checks
If you’re tired of formatting your code manually, this script automatically runs linters and
formatters to keep your code clean and consistent.
import subprocess
def auto_lint():
subprocess.run(["flake8", "."])
subprocess.run(["black", "."])
auto_lint()
15. Collaborative Document Updates
Keeping documents up-to-date across a team can be a nightmare. This script automates
syncing notes or documents across platforms.

import shutil
def sync_docs(source, destination):
shutil.copytree(source, destination, dirs_exist_ok=True)
print("Documents synced successfully")
sync_docs("/path/to/source", "/path/to/destination")
Personal Productivity
From managing your time better to automating parts of your daily routine, Python can help
boost your personal productivity and free up your mental space for more creative work.
16. Focus Timer
If you’re a fan of the Pomodoro technique, this script can automate your work and break
cycles, helping you stay focused without constantly checking the clock.
import time
def pomodoro_timer(work_time, break_time):
print(f"Work for {work_time} minutes")
time.sleep(work_time * 60)
print(f"Take a break for {break_time} minutes")
time.sleep(break_time * 60)
pomodoro_timer(25, 5)
17. Automated Journal Entries
Want to build a journaling habit but can’t find the time? This script prompts you to input daily
reflections and saves them automatically.
def journal_entry():
entry = input(f"What are your thoughts for {today}? ")
with open("journal.txt", "a") as file:
file.write(f"{today}: {entry}n")
journal_entry()
18. Routine Automation
Set up your daily routines effortlessly with this script that triggers specific tasks at certain
times of the day.
import time

def daily_routines():
morning_tasks = ["Check emails", "Review calendar", "Write to-do list"]
for task in morning_tasks:
print(f"Morning Task: {task}")
time.sleep(3600) # Wait an hour before the next set of tasks
daily_routines()
Financial Management
Let’s face it—managing money can be stressful. These automation scripts simplify tracking
your expenses, monitoring your investments, and even generating invoices.
19. Expense Tracker
No more manually updating your budget spreadsheet. This script automatically logs your
expenses and keeps your budget updated.
import csv
def log_expense(description, amount):
with open("expenses.csv", mode="a") as file:
writer = csv.writer(file)
writer.writerow([description, amount])
log_expense("Lunch", 12.50)
20. Investment Portfolio Monitor
Want to keep tabs on your stock portfolio without checking prices all day? This script
monitors your investments and sends alerts if anything changes significantly.
import requests
def check_stock_price(symbol):
response = requests.get(f"https://api.example.com/stocks/{symbol}")
data = response.json()
print(f"The current price of {symbol} is {data['price']}")
check_stock_price("AAPL")
21. Invoice Generation
If you’re a freelancer or small business owner, generating invoices can take up more time
than you’d like. This script automates the process, allowing you to generate invoices in
seconds.
from fpdf import FPDF

def create_invoice(client_name, amount):
pdf = FPDF()
pdf.add_page()
pdf.set_font("Arial", size=12)
pdf.cell(200, 10, f"Invoice for {client_name}", ln=True, align="C")
pdf.cell(200, 10, f"Amount Due: ${amount}", ln=True, align="C")
pdf.output(f"Invoice_{client_name}.pdf")
create_invoice("John Doe", 500)
Home Office Optimization
Working from home? These scripts can help you optimize your workspace by automating
small tasks, making your home office smarter and more efficient.
22. Smart Lighting Control
You don’t have to get up to adjust the lighting in your home office. This script can automate
your smart lights to match your productivity needs.
import requests
def control_lights(action):
requests.post(f"https://api.smartlights.com/{action}")
control_lights("turn_on")
23. Noise Level Monitoring
Too much noise can be distracting. This script monitors the noise levels in your workspace
and sends you an alert when it gets too loud.
import sounddevice as sd
def monitor_noise(threshold):
def callback(indata, frames, time, status):
volume_norm = int(indata.max() * 100)
if volume_norm > threshold:
print("Noise level too high!")
with sd.InputStream(callback=callback):
sd.sleep(10000)
monitor_noise(50)
24. Automated Coffee Brewing

Yes, you can even automate your coffee brewing. This script triggers your smart coffee
maker to start brewing at the perfect time, so your coffee is ready when you are.
import requests
def brew_coffee():
requests.post("https://api.smartcoffeemaker.com/start_brewing")
brew_coffee()
Learning and Skill Development
Whether you’re learning a new programming language or trying to stay on top of industry
trends, Python can help by automating study schedules, aggregating resources, and keeping
you on track.
25. Automated Study Schedules
This script sets up a study schedule for you, breaking down large topics into manageable
chunks and sending you daily reminders.
import datetime
def study_schedule(subjects):
for i, subject in enumerate(subjects):
print(f"Study {subject} on {today + datetime.timedelta(days=i)}")
subjects = ["Python", "Data Science", "Machine Learning"]
study_schedule(subjects)
26. Resource Aggregator
Stop wasting time searching for articles and resources. This script automatically collects and
organizes resources from your favorite websites.
import feedparser
def aggregate_resources(feed_url):
feed = feedparser.parse(feed_url)
for entry in feed.entries:
print(f"Title: {entry.title}, Link: {entry.link}")
aggregate_resources("https://example.com/rss")
27. Code Challenges Automation

If you’re practicing coding, this script sets up daily coding challenges for you to tackle, so
you can focus on improving your skills.
import random
def daily_code_challenge():
challenges = ["Reverse a string", "Find the largest number in a list", "Create a Fibonacci
sequence"]
challenge = random.choice(challenges)
print(f"Today's challenge: {challenge}")
daily_code_challenge()
Miscellaneous Utilities
These scripts don’t fit neatly into a specific category, but they’re still incredibly useful. From
scheduling social media posts to curating personalized news, there’s plenty here to make
your life easier.
28. Social Media Post Scheduler
If you’re managing social media accounts, this script can help by scheduling your posts in
advance.
import time
def schedule_post(content, post_time):
current_time = time.time()
delay = post_time - current_time
time.sleep(delay)
print(f"Posted: {content}")
schedule_post("Hello, world!", time.time() + 3600)
29. Weather Notifications
Why check the weather manually when you can have it sent to you automatically every
morning?
import requests
def get_weather(city):
response = requests.get(f"https://api.weather.com/v3/wx/conditions/current?city={city}")
data = response.json()
print(f"The current weather in {city} is {data['temperature']}°C with {data['description']}")
get_weather("New York")

30. Personalized News Aggregator
Stay informed without the noise. This script curates news articles based on your interests
and sends you a daily digest.
import requests
def personalized_news(keywords):
response =
requests.get(f"https://newsapi.org/v2/everything?q={keywords}&apiKey=your_api_key")
articles = response.json()['articles']
for article in articles:
print(f"Title: {article['title']}, Link: {article['url']}")
personalized_news("technology")
Highlights of Unique Scripts
Now that we’ve covered 30 scripts, I want to take a moment to highlight a few standouts that
have made a real difference in my own workflow.
● Batch Renaming Files: This script has saved me countless hours when working
with large collections of images and documents. Instead of manually renaming files, I
can let the script do all the heavy lifting.
● Web Scraping for Market Research: Whether you’re tracking competitors or
keeping an eye on price changes, automating web scraping can give you a serious
competitive edge.
● Automated Gantt Charts: As someone who works with multiple projects, this script
has helped me visualize timelines and avoid overbooking myself.
Personal Experiences and Anecdotes
When I first started using Python for automation, I wasn’t expecting the massive boost in
productivity it would bring. Take the Web Scraping for Market Research script, for
example. I remember spending hours manually checking competitor websites, jotting down
their prices and features. It was exhausting and error-prone. Once I set up the web scraping
script, though, the data came to me automatically. I could simply run the script, grab my
morning coffee, and within minutes, I had all the information I needed. That one script alone
saved me hours each week.
Another personal favorite is the Focus Timer script. As someone who struggles with staying
on task, the Pomodoro technique has been a lifesaver. But I found myself constantly
checking the clock, wondering when my next break would be. After automating the process
with Python, I didn’t need to think about it anymore. The script would tell me when to work

and when to take a break, and I could just focus on the task at hand. It was like having a
personal productivity coach sitting next to me, but without the pressure!
The Automated Coffee Brewing script might sound like a luxury, but let me tell you, it’s a
game-changer. I programmed it to start brewing my coffee five minutes before I usually wake
up. There’s nothing quite like the smell of fresh coffee greeting you as you roll out of bed. It’s
a small touch, but it makes mornings feel a little more seamless. Plus, it’s one less thing to
think about in my already busy day.
Financial Management Scripts: A Real-World Example
Managing my finances used to be a headache. Like many freelancers, I had to juggle
multiple invoices, track expenses, and monitor my investments. I’d spend hours each week
updating spreadsheets, calculating totals, and making sure I didn’t miss a payment. But once
I automated those processes with Python, everything changed.
Take the Expense Tracker script, for instance. I linked it to my bank’s CSV exports, so every
time I made a purchase, the script automatically logged the expense. Tracking my budget
became effortless. Instead of sitting down every Sunday to go over receipts, I could just
glance at my expense file and see how much I’d spent that week.
Then there’s the Invoice Generation script. This one was a game-changer. I used to dread
creating invoices—it felt like a necessary evil. But now, all I need to do is run the script, and
it generates a professional-looking PDF invoice in seconds. It pulls in relevant client details,
calculates totals, and even includes due dates. I just send the invoice off, and voilà—billing
done without breaking a sweat.
The Investment Portfolio Monitor script has also been a lifesaver. I’m not the kind of
person who wants to check stocks every day, but I do want to know when there’s a big
movement. With the script, I get automatic alerts when any of my investments see significant
changes. It’s like having a financial advisor without the hefty fees.
Home Office Optimization: My Experience
Working from home comes with its own set of challenges, but Python has helped me turn my
home office into a more efficient and productive space. The Smart Lighting Control script,
for example, has been a surprising productivity hack. I linked it to the time of day and my
calendar, so my lights automatically adjust based on what I’m doing. When I’m in a meeting
or deep work mode, the lights dim slightly to reduce glare on my screen. During breaks, they
brighten up to keep my energy levels high. It’s a subtle change, but over time, it’s made a
noticeable difference in my ability to stay focused.
Then there’s the Noise Level Monitoring script. My apartment building can get noisy, and
it’s hard to concentrate when there’s a lot of background noise. The script monitors noise

levels and sends me a notification when it gets too loud, so I can throw on some
noise-cancelling headphones or move to a quieter spot. It’s a simple solution, but it’s helped
me stay productive even in a less-than-ideal environment.
And, of course, I’ve already mentioned the Automated Coffee Brewing script. It’s a small
thing, but it’s made my mornings feel a little smoother and more enjoyable. Plus, it’s just fun
to show off to visitors—“Oh, don’t worry, the coffee will brew itself.”
Learning and Skill Development: Automating My
Growth
When I decided to learn Python, I wasn’t just looking for a new skill—I wanted to streamline
how I learn and grow. That’s where the Automated Study Schedules script came in handy.
I’m constantly juggling multiple learning goals, from improving my coding skills to keeping up
with industry trends. With the script, I can break down larger subjects into bite-sized daily
tasks and get reminders of what I need to focus on each day. It’s like having a personalized
tutor who keeps me on track without being overbearing.
The Resource Aggregator script has also been a huge time-saver. I used to spend hours
browsing different websites, bookmarking articles, and trying to keep up with the latest
trends in tech and business. Now, I’ve set up the script to pull in relevant articles from my
favorite sources and organize them in one place. Instead of wasting time searching for
information, I can spend more time actually learning and applying what I’ve read.
Finally, the Code Challenges Automation script has been great for keeping my
programming skills sharp. Every day, it serves up a different coding problem for me to tackle.
Some days, it’s something simple, like reversing a string, and other days, it’s a bit more
complex, like building a small algorithm. The variety keeps things interesting, and the daily
practice is helping me improve my problem-solving skills over time.
Miscellaneous Utilities: The Hidden Gems of
Automation
Not every automation script fits neatly into a category, but that doesn’t make them any less
valuable. In fact, some of the most useful scripts I’ve written are the ones that solve little,
everyday problems.
For example, the Weather Notifications script has become a daily part of my routine. I used
to check the weather app first thing in the morning, but now I get an automated message
with the day’s forecast as soon as I wake up. It’s a small convenience, but it’s one less thing
I need to think about during the morning rush.

Similarly, the Social Media Post Scheduler script has been a game-changer for managing
my online presence. I run a couple of social media accounts, and I used to spend way too
much time manually scheduling posts. Now, I just input the content and the time I want it
posted, and the script takes care of the rest. It’s helped me maintain a consistent presence
without feeling overwhelmed by the scheduling process.
Finally, the Personalized News Aggregator script has been an amazing tool for staying
informed without information overload. I’m interested in a lot of different topics—technology,
finance, productivity hacks—but it’s easy to get lost in the flood of news. The script curates
articles based on my stated interests and sends me a daily digest of the top stories. It’s like
having my own personal news assistant who only brings me the information I care about
most.
Closing Thoughts
Automation isn’t just a buzzword—it’s a game-changer. Whether you’re looking to save time,
reduce repetitive tasks, or simply make your life a little easier, Python has a script for that.
From managing your files to tracking your finances, from boosting your productivity to
optimizing your home office, automation can help you work smarter, not harder.
These 51 Python scripts are just the beginning. Once you start automating, you’ll find that
there are endless possibilities for streamlining your daily tasks. And the best part? You don’t
need to be a professional programmer to make it work. Many of these scripts can be
customized with just a few lines of code, and once they’re set up, they’ll run in the
background, quietly improving your life without any extra effort on your part.
So, what are you waiting for? Start small—maybe with a simple task like organizing your
desktop or automating your email filtering. Once you see the power of automation in action,
you’ll wonder how you ever lived without it. And who knows? You might even get inspired to
write your own scripts and take automation to the next level.
In the end, it all comes down to this: automation frees you up to focus on the things that
really matter. Whether that’s growing your business, learning a new skill, or just spending
more time doing what you love, Python can help you get there. So go ahead—embrace
automation, and let Python handle the rest.
Recommendation:
1. Python for Beginners: Learn the basics of python coding language including
features, tasks and applications with this free online course.sign up Here
2. Diploma in Python for Beginners: Learn how to use Python 3's graphic user
interface (GUI) and command-line interface (CLI) in this free online course.
Sign up here

3. Advanced Diploma in Python Programming for the Novice to Expert: Get to know
and apply the advanced functions, tools, and applications of Python coding with this
free online course. Sign up here
4. How To Effortlessly Build AI-Powered Workflows with Leap AI’s No-Code
Drag-and-Drop Interface

Boost Productivity with 30 Simple Python Scripts.pdf

More Related Content

Similar to Boost Productivity with 30 Simple Python Scripts.pdf (20)

More from SOFTTECHHUB (20)

Recently uploaded (20)

Boost Productivity with 30 Simple Python Scripts.pdf