20 Python Scripts to Automate Everyday Tasks

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 requests library.

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

import requests

def download_file(url, destination_folder):
    response = requests.get(url)
    if response.status_code == 200:
        with open(destination_folder, 'wb') as file:
            file.write(response.content)
        print(f"Downloaded {url} to {destination_folder}")
    else:
        print(f"Failed to download {url}")

url="https://example.com/file.pdf" destination = '/path/to/destination/file.pdf' download_file(url, destination)

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

Web scraping is a powerful technique for automating data collection from websites, and Python’s BeautifulSoup and requests libraries make this process straightforward.

import requests
from bs4 import BeautifulSoup

def scrape_website(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    data = soup.find_all('h1')  # Example: Get all headings
    for item in data:
        print(item.text)

url="https://example.com" scrape_website(url)

This script fetches the content from a webpage and prints out all the headings (h1 tags). You can adjust it to scrape other types of data.

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 os
import time

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

folder="/path/to/your/folder" clean_up(folder, 30) # Delete files older than 30 days

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 string

def generate_password(length=12):
    # Define the character set: letters, digits, and punctuation
    characters = string.ascii_letters + string.digits + string.punctuation
    
    # Generate a random password
    password = ''.join(random.choice(characters) for _ in range(length))
    
    return password

# Example usage: generate a password of 16 characters
password_length = 16
random_password = generate_password(password_length)
print(f"Generated Password: {random_password}")

13. Task Tracker/Reminder

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

import schedule
import time
from datetime import datetime

def task_reminder(task_name):
    print(f"Reminder: {task_name} - {datetime.now()}")

schedule.every().day.at("09:00").do(task_reminder, task_name="Morning Meeting")

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

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

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

data = ["Task 1: Completed", "Task 2: Pending", "Task 3: Completed"]
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

def resize_images(folder_path, width, height):
    for filename in os.listdir(folder_path):
        if filename.endswith('.jpg'):
            img = Image.open(os.path.join(folder_path, filename))
            img = img.resize((width, height))
            img.save(os.path.join(folder_path, f"resized_{filename}"))
            print(f"Resized {filename}")

folder="/path/to/your/images" 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)

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!