21 Simple Python Scripts That Will Automate Your Daily Tasks

As someone who has spent over a decade in the programming world, I’ve learned that automating repetitive tasks can save a significant amount of time and effort.

Python, with its simple syntax and powerful libraries, is one of the best programming languages for creating automation scripts. Whether you’re a programmer or someone looking to make daily tasks easier, Python has tools that can help you.

In this article, I’ll share 21 Python scripts that I’ve used to automate various tasks. These scripts are perfect for anyone who wants to save time and improve efficiency in their work routine.

1. Renaming Files in Bulk

Renaming files one by one can be a time-consuming task, but with Python, you can easily automate this by using the os module.

Here’s a simple script that renames multiple files in a folder based on a given pattern:

import os

def bulk_rename(folder_path, old_name_part, new_name_part):
    for filename in os.listdir(folder_path):
        if old_name_part in filename:
            new_filename = filename.replace(old_name_part, new_name_part)
            os.rename(os.path.join(folder_path, filename), os.path.join(folder_path, new_filename))
            print(f"Renamed {filename} to {new_filename}")

folder = '/path/to/your/folder' bulk_rename(folder, 'old_part', 'new_part')

This script searches for files containing old_name_part in their names and replaces it with new_name_part.

2. Backing Up Files Automatically

We all know how important it is to back up files regularly, and this task can be easily automated using Python’s shutil module.

This script will copy all files from one directory to another for backup purposes:

import shutil
import os

def backup_files(src_dir, dest_dir):
    if not os.path.exists(dest_dir):
        os.makedirs(dest_dir)
    for file in os.listdir(src_dir):
        full_file_name = os.path.join(src_dir, file)
        if os.path.isfile(full_file_name):
            shutil.copy(full_file_name, dest_dir)
            print(f"Backed up {file} to {dest_dir}")

source = '/path/to/source/directory' destination = '/path/to/destination/directory' backup_files(source, destination)

You can schedule this script to run daily using task-scheduling tools like cron (Linux) or Task Scheduler (Windows).

3. Downloading Files from the Internet

If you frequently download files from the internet, then you can automate this task using aiohttp library.

Here’s a simple script to download files from URLs:

import aiohttp
import asyncio
import aiofiles

async def download_file(url, filename):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            async with aiofiles.open(filename, 'wb') as file:
                await file.write(await response.read())
            print(f"Downloaded {filename}")

urls = {
    'https://example.com/file1.zip': 'file1.zip',
    'https://example.com/file2.zip': 'file2.zip'
}

async def download_all():
    tasks = [download_file(url, filename) for url, filename in urls.items()]
    await asyncio.gather(*tasks)

asyncio.run(download_all())

This script downloads the file from the specified URL and saves it to your specified folder.

4. Automating Email Reports

If you’re required to send email reports regularly, you can automate it using smtplib library, which allows you to send emails from a Gmail account easily:

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

def send_email(subject, body, to_email):
    sender_email = '[email protected]'
    sender_password = 'yourpassword'
    receiver_email = to_email

    msg = MIMEMultipart()
    msg['From'] = sender_email
    msg['To'] = receiver_email
    msg['Subject'] = subject
    msg.attach(MIMEText(body, 'plain'))

    try:
        server = smtplib.SMTP('smtp.gmail.com', 587)
        server.starttls()
        server.login(sender_email, sender_password)
        server.sendmail(sender_email, receiver_email, msg.as_string())
        server.quit()
        print("Email sent successfully!")
    except Exception as e:
        print(f"Failed to send email: {e}")

subject = 'Monthly Report'
body = 'Here is the monthly report.'
send_email(subject, body, '[email protected]')

This script will send a simple email with a subject and body to a specified recipient. Make sure to enable less secure apps in Gmail if you use this method.

5. Task Scheduler (Task Automation)

Scheduling tasks can be done easily using the schedule library, which allows you to automate tasks like sending an email or running a backup script at specific times:

import schedule
import time

def job():
    print("Running scheduled task!")

# Schedule the task to run every day at 10:00 AM
schedule.every().day.at("10:00").do(job)

while True:
    schedule.run_pending()
    time.sleep(1)

This script will keep running and trigger tasks at the specified time, in this case, 10:00 AM every day.

6. Web Scraping for Data Collection

Using aiohttp for asynchronous HTTP requests instead of the synchronous requests library can make web scraping more efficient.

This example retrieves multiple pages in parallel.

import aiohttp
import asyncio
from bs4 import BeautifulSoup

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def scrape(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        html_pages = await asyncio.gather(*tasks)
        for html in html_pages:
            soup = BeautifulSoup(html, 'html.parser')
            print(soup.title.string)

urls = ['https://example.com/page1', 'https://example.com/page2'] asyncio.run(scrape(urls))

7. Automating Social Media Posts

If you manage social media accounts, then you can automate posting by using the libraries like Tweepy (for Twitter) and Instagram-API (for Instagram) allow you to post automatically.

Below is an example using the Tweepy library to post a tweet:

import tweepy

def tweet(message):
    consumer_key = 'your_consumer_key'
    consumer_secret = 'your_consumer_secret'
    access_token = 'your_access_token'
    access_token_secret = 'your_access_token_secret'

    auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
    auth.set_access_token(access_token, access_token_secret)

    api = tweepy.API(auth)

    api.update_status(message)
    print("Tweet sent successfully!")

tweet("Hello, world!")

This script posts a tweet with the message “Hello, world!” to your Twitter account.

8. Automating Invoice Generation

If you generate invoices regularly, then you can automate it using libraries like Fpdf, which will create PDF invoices:

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, txt="Invoice", ln=True, align='C')
    pdf.cell(200, 10, txt=f"Client: {client_name}", ln=True, align='L')
    pdf.cell(200, 10, txt=f"Amount: ${amount}", ln=True, align='L')
    pdf.output(f"{client_name}_invoice.pdf")
    print(f"Invoice for {client_name} created successfully!")

create_invoice('John Doe', 500)

This script creates a simple invoice and saves it as a PDF.

9. Monitoring Website Uptime

Python can be used to automate monitoring of website uptime using the requests library, that can periodically check if a website is online or not:

import requests
import time

def check_website(url):
    try:
        response = requests.get(url)
        if response.status_code == 200:
            print(f"Website {url} is up!")
        else:
            print(f"Website {url} returned a status code {response.status_code}")
    except requests.exceptions.RequestException as e:
        print(f"Error checking website {url}: {e}")

url = 'https://example.com' while True: check_website(url) time.sleep(3600) # Check every hour

This script checks if the website is online and prints the status code.

10. Auto-Reply to Emails

If you often receive emails and want to set up an auto-reply, then use the imaplib and smtplib libraries to automatically reply to emails:

import imaplib
import smtplib
from email.mime.text import MIMEText

def auto_reply():
    # Connect to email server
    mail = imaplib.IMAP4_SSL("imap.gmail.com")
    mail.login('[email protected]', 'yourpassword')
    mail.select('inbox')

    # Search for unread emails
    status, emails = mail.search(None, 'UNSEEN')

    if status == "OK":
        for email_id in emails[0].split():
            status, email_data = mail.fetch(email_id, '(RFC822)')
            email_msg = email_data[0][1].decode('utf-8')

            # Send auto-reply
            send_email("Auto-reply", "Thank you for your email. I'll get back to you soon.", '[email protected]')

def send_email(subject, body, to_email):
    sender_email = '[email protected]'
    sender_password = 'yourpassword'
    receiver_email = to_email

    msg = MIMEText(body)
    msg['From'] = sender_email
    msg['To'] = receiver_email
    msg['Subject'] = subject

    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
        server.login(sender_email, sender_password)
        server.sendmail(sender_email, receiver_email, msg.as_string())

auto_reply()

This script automatically replies to unread emails with a predefined message.

11. File Cleanup

Python provides an effective way to automate file cleanup, particularly for deleting or moving old files to maintain organized directories.

Below is a simple script that deletes files older than a specified number of days using the os and time modules.

import aiofiles
import os
import asyncio
import time

async def clean_up(folder_path, days_old):
    now = time.time()
    cutoff_time = now - (days_old * 86400)
    for filename in os.listdir(folder_path):
        file_path = os.path.join(folder_path, filename)
        if os.path.getmtime(file_path) < cutoff_time:
            await aiofiles.os.remove(file_path)
            print(f"Deleted {filename}")

folder = '/path/to/your/folder'
asyncio.run(clean_up(folder, 30))

12. Generate Passwords Automatically

Creating strong, unique passwords is essential for security, and Python can help automate this process using the random module.

Below is a simple script that generates random passwords of a specified length, incorporating letters, digits, and special characters to enhance security.

import random
import asyncio
import string

async def generate_password(length=12):
    characters = string.ascii_letters + string.digits + string.punctuation
    password = ''.join(random.choice(characters) for _ in range(length))
    return password

async def generate_multiple_passwords(n, length=12):
    tasks = [generate_password(length) for _ in range(n)]
    passwords = await asyncio.gather(*tasks)
    print(passwords)

asyncio.run(generate_multiple_passwords(5))

13. Task Tracker/Reminder

Creating a task tracker or reminder system in Python can be accomplished using the datetime and asyncio modules.

import asyncio
from datetime import datetime

async def task_reminder(task_name, interval):
    while True:
        print(f"Reminder: {task_name} - {datetime.now()}")
        await asyncio.sleep(interval)

async def main():
    await asyncio.gather(
        task_reminder("Drink Water", 7200),  # Remind every 2 hours
        task_reminder("Take a Break", 3600)  # Remind every 1 hour
    )

asyncio.run(main())

This script sends a reminder about the task at a scheduled time.

14. Auto-Generate Daily Reports

Automate daily reports by using Python to collect data and format it into a report:

import datetime
import aiofiles
import asyncio

async def generate_report(data):
    today = datetime.date.today()
    filename = f"daily_report_{today}.txt"
    async with aiofiles.open(filename, 'w') as file:
        await file.write(f"Report for {today}\n")
        await file.write("\n".join(data))
    print(f"Report generated: {filename}")

data = ["Task 1: Completed", "Task 2: Pending", "Task 3: Completed"]
asyncio.run(generate_report(data))

15. Monitor System Resources

If you’re a system administrator, you can use Python to monitor your system’s resources like CPU and memory usage, with the help of psutil library.

import psutil

def monitor_resources():
    cpu_usage = psutil.cpu_percent(interval=1)
    memory_usage = psutil.virtual_memory().percent
    print(f"CPU Usage: {cpu_usage}%")
    print(f"Memory Usage: {memory_usage}%")

monitor_resources()

16. Batch Image Resizing

If you need to resize images in bulk, Python makes it easy with the Pillow library.

from PIL import Image
import os
import asyncio
from concurrent.futures import ProcessPoolExecutor

def resize_image(filename, width, height):
    img = Image.open(filename)
    img = img.resize((width, height))
    img.save(f"resized_{filename}")
    return f"Resized {filename}"

async def resize_images(folder_path, width, height):
    with ProcessPoolExecutor() as executor:
        loop = asyncio.get_event_loop()
        tasks = []
        for filename in os.listdir(folder_path):
            if filename.endswith('.jpg'):
                tasks.append(loop.run_in_executor(
                    executor, resize_image, os.path.join(folder_path, filename), width, height))
        results = await asyncio.gather(*tasks)
        print(results)

folder = '/path/to/your/images'
asyncio.run(resize_images(folder, 800, 600))

This script resizes all .jpg images in a folder to the specified dimensions.

17. Automating Data Backup to Cloud

Automating backups to cloud services like Google Drive is made possible with Python using libraries such as pydrive.

from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive

def backup_to_google_drive(file_path):
    gauth = GoogleAuth()
    gauth.LocalWebserverAuth()
    drive = GoogleDrive(gauth)
    file = drive.CreateFile({'title': 'backup_file.txt'})
    file.Upload()
    print("Backup uploaded successfully!")

file = '/path/to/your/file.txt' backup_to_google_drive(file)

18. Creating Daily Reminders

Setting daily reminders is easy with the time module, which will remind you to drink water every 2 hours:

import time

def water_reminder():
    while True:
        print("Time to drink water!")
        time.sleep(7200)  # Remind every 2 hours

water_reminder()

19. Automating Data Entry to Excel

If you frequently enter data into Excel, Python can help automate this task with the openpyxl library:

from openpyxl import Workbook

def create_excel(data):
    wb = Workbook()
    ws = wb.active
    for row in data:
        ws.append(row)
    wb.save('data.xlsx')
    print("Excel file created successfully!")

data = [
    ["Name", "Age", "City"],
    ["John", 30, "New York"],
    ["Anna", 25, "London"],
]
create_excel(data)

20. Automating Data Cleaning

If you work with large datasets, Python can automate data-cleaning tasks, which will remove empty rows from a CSV file:

import csv

def clean_csv(file_path):
    with open(file_path, 'r') as infile:
        reader = csv.reader(infile)
        rows = [row for row in reader if any(row)]
    
    with open(file_path, 'w', newline='') as outfile:
        writer = csv.writer(outfile)
        writer.writerows(rows)
    
    print("Empty rows removed from CSV")

file = '/path/to/your/data.csv' clean_csv(file)

21. Text Extract from Images

Python can be used to extract text from images using the pytesseract library, which can be useful when you need to digitize printed content or extract text from scanned documents.

from PIL import Image
import pytesseract

def extract_text_from_image(image_path):
    # Open the image file
    img = Image.open(image_path)
    
    # Use pytesseract to extract text
    text = pytesseract.image_to_string(img)
    
    return text

image_path = 'path_to_your_image.jpg'
extracted_text = extract_text_from_image(image_path)
print("Extracted Text:\n", extracted_text)

Conclusion

These are just a few examples of what Python can do to automate your daily tasks. With its simple syntax and powerful libraries, Python can handle almost any task you throw at it.

Whether you’re managing files, sending emails, or generating reports, Python can save you time and improve your productivity. So, get started with Python automation today, and let it handle your daily chores!