Als jemand, der über ein Jahrzehnt in der Programmierwelt verbracht hat, habe ich gelernt, dass die Automatisierung wiederkehrender Aufgaben eine erhebliche Menge an Zeit und Mühe sparen kann.
Python mit seiner einfachen Syntax und leistungsstarken Bibliotheken ist eine der besten Programmiersprachen zur Erstellung von Automatisierungsskripten. Egal, ob Sie ein Programmierer sind oder jemand, der tägliche Aufgaben erleichtern möchte, Python hat Werkzeuge, die Ihnen helfen können.
In diesem Artikel werde ich 21 Python-Skripte teilen, die ich verwendet habe, um verschiedene Aufgaben zu automatisieren. Diese Skripte sind perfekt für jeden, der Zeit sparen und die Effizienz in seinem Arbeitsablauf verbessern möchte.
1. Dateien in Massen umbenennen
Dateien einzeln umzubenennen kann eine zeitaufwändige Aufgabe sein, aber mit Python können Sie dies einfach automatisieren, indem Sie das os-Modul verwenden.
Hier ist ein einfaches Skript, das mehrere Dateien in einem Ordner basierend auf einem gegebenen Muster umbenennt:
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')
Dieses Skript sucht nach Dateien, die old_name_part in ihren Namen enthalten, und ersetzt es durch new_name_part.
2. Dateien automatisch sichern
Wir alle wissen, wie wichtig es ist, Dateien regelmäßig zu sichern, und diese Aufgabe kann leicht mit dem shutil-Modul von Python automatisiert werden.
Dieses Skript kopiert alle Dateien von einem Verzeichnis in ein anderes zu Sicherungszwecken:
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)
Sie können dieses Skript so planen, dass es täglich mit Aufgabenplanungs-Tools wie cron (Linux) oder Task Scheduler (Windows) ausgeführt wird.
3. Herunterladen von Dateien aus dem Internet
Wenn Sie häufig Dateien aus dem Internet herunterladen, können Sie diese Aufgabe mit der aiohttp-Bibliothek automatisieren.
Hier ist ein einfaches Skript zum Herunterladen von Dateien von 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())
Dieses Skript lädt die Datei von der angegebenen URL herunter und speichert sie in Ihrem angegebenen Ordner.
4. Automatisierung von E-Mail-Berichten
Wenn Sie regelmäßig E-Mail-Berichte versenden müssen, können Sie dies mit der smtplib-Bibliothek automatisieren, die es Ihnen ermöglicht, ganz einfach E-Mails von einem Gmail-Konto zu senden:
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]')
Dieses Skript sendet eine einfache E-Mail mit Betreff und Text an einen angegebenen Empfänger. Stellen Sie sicher, dass Sie in Gmail weniger sichere Apps aktivieren, wenn Sie diese Methode verwenden.
5. Aufgabenplanung (Aufgabenautomatisierung)
Die Planung von Aufgaben kann einfach mit der schedule-Bibliothek erfolgen, die es Ihnen ermöglicht, Aufgaben wie das Senden einer E-Mail oder das Ausführen eines Backup-Skripts zu bestimmten Zeiten zu automatisieren:
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)
Dieses Skript wird weiterhin ausgeführt und löst Aufgaben zur angegebenen Zeit aus, in diesem Fall jeden Tag um 10:00 Uhr.
6. Web Scraping zur Datenerfassung
Die Verwendung von aiohttp für asynchrone HTTP-Anfragen anstelle der synchronen requests-Bibliothek kann das Web-Scraping effizienter machen.
In diesem Beispiel werden mehrere Seiten parallel abgerufen.
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. Automatisierung von Social-Media-Beiträgen
Wenn Sie Social-Media-Konten verwalten, können Sie das Posten automatisieren, indem Sie Bibliotheken wie Tweepy (für Twitter) und Instagram-API (für Instagram) verwenden, um automatisch Beiträge zu veröffentlichen.
Im Folgenden finden Sie ein Beispiel zur Verwendung der Tweepy-Bibliothek zum Veröffentlichen eines Tweets:
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!")
Dieses Skript veröffentlicht einen Tweet mit der Nachricht „Hallo, Welt!“ auf Ihrem Twitter-Konto.
8. Automatisierung der Rechnungserstellung
Wenn Sie regelmäßig Rechnungen erstellen, können Sie dies mit Bibliotheken wie Fpdf automatisieren, die PDF-Rechnungen erstellen werden:
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)
Dieses Skript erstellt eine einfache Rechnung und speichert sie als PDF.
9. Überwachung der Website-Verfügbarkeit
Mit Python können Sie die Überwachung der Website-Verfügbarkeit mit der requests-Bibliothek automatisieren, die regelmäßig prüfen kann, ob eine Website online ist oder nicht:
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
Dieses Skript überprüft, ob die Website online ist, und gibt den Statuscode aus.
10. Automatische Antwort auf E-Mails
Wenn Sie häufig E-Mails erhalten und eine automatische Antwort einrichten möchten, verwenden Sie die Bibliotheken imaplib und smtplib, um automatisch auf E-Mails zu antworten:
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()
Dieses Skript antwortet automatisch auf ungelesene E-Mails mit einer vordefinierten Nachricht.
11. Dateibereinigung
Python bietet eine effektive Möglichkeit, die Dateiaufräumarbeiten zu automatisieren, insbesondere zum Löschen oder Verschieben alter Dateien, um organisierte Verzeichnisse aufrechtzuerhalten.
Im Folgenden finden Sie ein einfaches Skript, das Dateien löscht, die älter als eine bestimmte Anzahl von Tagen sind, unter Verwendung der Module os und time.
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. Passwörter automatisch generieren
Das Erstellen starker, einzigartiger Passwörter ist für die Sicherheit unerlässlich, und Python kann diesen Prozess mithilfe des Moduls random automatisieren.
Im Folgenden finden Sie ein einfaches Skript, das zufällige Passwörter einer bestimmten Länge generiert und Buchstaben, Zahlen und Sonderzeichen zur Verbesserung der Sicherheit integriert.
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. Aufgabenverfolgung/Erinnerung
Das Erstellen eines Aufgabenverfolgungs- oder Erinnerungssystems in Python kann mithilfe der Module datetime und asyncio erreicht werden.
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())
Dieses Skript sendet zur geplanten Zeit eine Erinnerung an die Aufgabe.
14. Automatische Generierung von täglichen Berichten
Automatisieren Sie tägliche Berichte, indem Sie Python verwenden, um Daten zu sammeln und in einen Bericht zu formatieren:
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. Überwachung der Systemressourcen
Wenn Sie ein Systemadministrator sind, können Sie Python verwenden, um die Ressourcen Ihres Systems wie CPU- und Speicherauslastung mit Hilfe der psutil-Bibliothek zu überwachen.
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. Stapelverarbeitung zur Bildgrößenänderung
Wenn Sie Bilder in großen Mengen skalieren müssen, macht Python dies mit der Pillow-Bibliothek einfach.
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))
Dieses Skript ändert die Größe aller .jpg-Bilder in einem Ordner auf die angegebenen Abmessungen.
17. Automatisches Daten-Backup in die Cloud
Die Automatisierung von Backups in Cloud-Diensten wie Google Drive ist mit Python mithilfe von Bibliotheken wie pydrive möglich.
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. Erstellung täglicher Erinnerungen
Das Einrichten täglicher Erinnerungen ist mit dem time-Modul einfach, das Sie alle 2 Stunden daran erinnern wird, Wasser zu trinken:
import time
def water_reminder():
while True:
print("Time to drink water!")
time.sleep(7200) # Remind every 2 hours
water_reminder()
19. Automatisches Eintragen von Daten in Excel
Wenn Sie häufig Daten in Excel eingeben, kann Ihnen Python mit der Bibliothek openpyxl bei der Automatisierung dieser Aufgabe helfen:
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. Automatisches Datenbereinigen
Wenn Sie mit großen Datensätzen arbeiten, kann Python Aufgaben zur Datenbereinigung automatisieren, indem leere Zeilen aus einer CSV-Datei entfernt werden:
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. Textextraktion aus Bildern
Mit Python kann Text aus Bildern mithilfe der pytesseract-Bibliothek extrahiert werden, was nützlich sein kann, wenn Sie gedruckte Inhalte digitalisieren oder Text aus gescannten Dokumenten extrahieren müssen.
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
Dies sind nur einige Beispiele dafür, was Python tun kann, um Ihre täglichen Aufgaben zu automatisieren. Mit seiner einfachen Syntax und leistungsstarken Bibliotheken kann Python fast jede Aufgabe bewältigen, die Sie ihm stellen.
Ob Sie Dateien verwalten, E-Mails senden oder Berichte generieren, Python kann Ihnen Zeit sparen und Ihre Produktivität steigern. Fangen Sie also heute mit der Python-Automatisierung an und lassen Sie sie Ihre täglichen Aufgaben erledigen!