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
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)
Below is a simple script that generates random passwords of a specified length, incorporating letters, digits, and special characters to enhance security.
1. Renaming Files in Bulk
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))
If you frequently download files from the internet, then you can automate this task using aiohttp library.
Using aiohttp for asynchronous HTTP requests instead of the synchronous requests library can make web scraping more efficient.
2. Backing Up Files Automatically
Python provides an effective way to automate file cleanup, particularly for deleting or moving old files to maintain organized directories.
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 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‘)
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())
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.
Automate daily reports by using Python to collect data and format it into a report:
4. Automating Email Reports
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
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]’)
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
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())
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
Below is a simple script that deletes files older than a specified number of days using the os and time modules.
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 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!”)
If you generate invoices regularly, then you can automate it using libraries like Fpdf, which will create PDF invoices:
8. Automating Invoice Generation
Here’s a simple script to download files from URLs:
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
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
We all know how important it is to back up files regularly, and this task can be easily automated using Python’s shutil module.
10. Auto-Reply to Emails
Below is an example using the Tweepy library to post a tweet:
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
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
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
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.
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()
Automating backups to cloud services like Google Drive is made possible with Python using libraries such as pydrive.
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!
14. Auto-Generate Daily Reports
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)
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
Here’s a simple script that renames multiple files in a folder based on a given pattern:
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:
17. Automating Data Backup to Cloud
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 copy all files from one directory to another for backup purposes:
Renaming files one by one can be a time-consuming task, but with Python, you can easily automate this by using the os module.
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:
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.
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
This example retrieves multiple pages in parallel.
