Als iemand die meer dan tien jaar in de programmeerwereld heeft doorgebracht, heb ik geleerd dat het automatiseren van repetitieve taken een aanzienlijke hoeveelheid tijd en moeite kan besparen.
Python, met zijn eenvoudige syntaxis en krachtige bibliotheken, is een van de beste programmeertalen voor het maken van automatiseringsscripts. Of je nu een programmeur bent of iemand die dagelijkse taken gemakkelijker wil maken, Python heeft tools die je kunnen helpen.
In dit artikel deel ik 21 Python-scripts die ik heb gebruikt om verschillende taken te automatiseren. Deze scripts zijn perfect voor iedereen die tijd wil besparen en de efficiëntie in hun werkroutine wil verbeteren.
1. Bestanden in bulk hernoemen
Het één voor één hernoemen van bestanden kan een tijdrovende taak zijn, maar met Python kun je dit eenvoudig automatiseren met behulp van de os-module.
Hier is een eenvoudig script dat meerdere bestanden hernoemt in een map op basis van een gegeven patroon:
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')
Dit script zoekt naar bestanden die old_name_part in hun namen bevatten en vervangt het door new_name_part.
2. Automatisch bestanden back-uppen
We weten allemaal hoe belangrijk het is om regelmatig bestanden te back-uppen, en deze taak kan gemakkelijk worden geautomatiseerd met behulp van de shutil-module van Python.
Dit script kopieert alle bestanden van de ene directory naar de andere voor back-updoeleinden:
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)
Je kunt dit script dagelijks laten uitvoeren met behulp van taakplanningshulpmiddelen zoals cron (Linux) of Taakplanner (Windows).
3. Bestanden downloaden van het internet
Als je vaak bestanden van het internet downloadt, kun je deze taak automatiseren met behulp van de aiohttp bibliotheek.
Hier is een eenvoudig script om bestanden van URL’s te downloaden:
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())
Dit script downloadt het bestand van de opgegeven URL en slaat het op in je opgegeven map.
4. E-mailrapporten automatiseren
Als je regelmatig e-mailrapporten moet versturen, kun je dit automatiseren met behulp van de smtplib bibliotheek, waarmee je eenvoudig e-mails vanuit een Gmail-account kunt verzenden:
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]')
Dit script stuurt een eenvoudige e-mail met een onderwerp en inhoud naar een opgegeven ontvanger. Zorg ervoor dat je minder veilige apps inschakelt in Gmail als je deze methode gebruikt.
5. Taakplanner (Taakautomatisering)
Het plannen van taken kan eenvoudig worden gedaan met behulp van de schedule bibliotheek, waarmee je taken zoals het verzenden van een e-mail of het uitvoeren van een back-upscript op specifieke tijden kunt automatiseren:
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)
Dit script blijft draaien en voert taken uit op de opgegeven tijd, in dit geval, 10:00 AM elke dag.
6. Webscraping voor gegevensverzameling
Het gebruik van aiohttp voor asynchrone HTTP-verzoeken in plaats van de synchrone requests bibliotheek kan web scraping efficiënter maken.
Dit voorbeeld haalt meerdere pagina’s tegelijk op.
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. Social Media Berichten Automatiseren
Als u sociale media-accounts beheert, kunt u het plaatsen automatiseren door gebruik te maken van bibliotheken zoals Tweepy (voor Twitter) en Instagram-API (voor Instagram) die automatisch berichten kunnen plaatsen.
Hieronder staat een voorbeeld met de Tweepy bibliotheek om een tweet te plaatsen:
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!")
Deze script plaatst een tweet met de boodschap “Hallo, wereld!” op uw Twitter-account.
8. Automatiseren van Factuur Generatie
Als u regelmatig facturen genereert, kunt u dit automatiseren met bibliotheken zoals Fpdf, waarmee u PDF-facturen kunt maken:
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)
Deze script maakt een eenvoudige factuur en slaat het op als een PDF.
9. Monitoren van Website Uptime
Python kan worden gebruikt om het monitoren van de uptime van websites te automatiseren met behulp van de requests bibliotheek, die periodiek kan controleren of een website online is of niet:
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
Deze script controleert of de website online is en print de statuscode.
10. Automatisch Antwoorden op E-mails
Als u vaak e-mails ontvangt en een automatisch antwoord wilt instellen, gebruik dan de imaplib en smtplib bibliotheken om automatisch te antwoorden op e-mails:
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()
Deze script antwoord automatisch op ongelezen e-mails met een vooraf gedefinieerde boodschap.
11. Bestandsopruiming
Python biedt een effectieve manier om bestandsopruiming te automatiseren, vooral voor het verwijderen of verplaatsen van oude bestanden om georganiseerde mappen te behouden.
Hieronder staat een eenvoudig script dat bestanden verwijdert die ouder zijn dan een opgegeven aantal dagen met behulp van de os– en tijd-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. Genereer wachtwoorden automatisch
Het maken van sterke, unieke wachtwoorden is essentieel voor beveiliging, en Python kan helpen bij het automatiseren van dit proces met behulp van de willekeurig-module.
Hieronder staat een eenvoudig script dat willekeurige wachtwoorden genereert van een opgegeven lengte, waarbij letters, cijfers en speciale tekens worden opgenomen om de beveiliging te verbeteren.
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. Taaktracker/Herinnering
Het maken van een taaktracker of herinneringssysteem in Python kan worden bereikt met behulp van de datetime– en 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())
Dit script stuurt een herinnering over de taak op een gepland tijdstip.
14. Dagelijkse rapporten automatisch genereren
Automatiseer dagelijkse rapporten door Python te gebruiken om gegevens te verzamelen en deze in een rapport te formatteren:
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. Bewaak systeembronnen
Als je een systeembeheerder bent, kun je Python gebruiken om de systeembronnen zoals CPU- en geheugenverbruik te monitoren, met behulp van de psutil-bibliotheek.
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 Afbeeldingsformaat wijzigen
Als je afbeeldingen in bulk moet aanpassen, maakt Python het eenvoudig met de Pillow bibliotheek.
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))
Dit script past alle .jpg afbeeldingen in een map aan naar de opgegeven afmetingen.
17. Automatiseren van Gegevensback-up naar de Cloud
Het automatiseren van back-ups naar clouddiensten zoals Google Drive is mogelijk met Python met behulp van bibliotheken zoals 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. Dagelijkse Herinneringen Maken
Het instellen van dagelijkse herinneringen is eenvoudig met de time module, die je elke 2 uur eraan herinnert om water te drinken:
import time
def water_reminder():
while True:
print("Time to drink water!")
time.sleep(7200) # Remind every 2 hours
water_reminder()
19. Automatiseren van Gegevensinvoer naar Excel
Als je vaak gegevens invoert in Excel, kan Python deze taak automatiseren met de openpyxl bibliotheek:
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. Automatiseren van Gegevensopschoning
Als je werkt met grote datasets, kan Python taken voor gegevensopschoning automatiseren, zoals het verwijderen van lege rijen uit een CSV-bestand:
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. Tekst Extractie uit Afbeeldingen
Python kan worden gebruikt om tekst uit afbeeldingen te extraheren met behulp van de pytesseract bibliotheek, wat handig kan zijn wanneer je gedrukte inhoud moet digitaliseren of tekst uit gescande documenten wilt halen.
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)
Conclusie
Dit zijn slechts enkele voorbeelden van wat Python kan doen om je dagelijkse taken te automatiseren. Met zijn eenvoudige syntaxis en krachtige bibliotheken kan Python bijna elke taak die je hem toevertrouwt aan.
Of je nu bestanden beheert, e-mails verstuurt of rapporten genereert, Python kan je tijd besparen en je productiviteit verbeteren. Begin vandaag nog met Python automatisering en laat het je dagelijkse taken afhandelen!