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 20 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 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!
