21 סקריפטים פשוטים ב-Python שיאוטומציה את המשימות היומיות שלך

כמי שבילה מעל עשור בעולם התכנות, למדתי שאוטומציה של משימות חוזרות יכולה לחסוך כמות משמעותית של זמן ומאמץ.

Python, עם התחביר הפשוט והספריות החזקות שלה, היא אחת משפות התכנות הטובות ביותר ליצירת סקריפטים לאוטומציה. בין אם אתם מתכנתים או מישהו שמחפש להקל על המשימות היומיות, Python מציעה כלים שיכולים לעזור לכם.

במאמר זה, אני אשתף 21 סקריפטים ב-Python שבהם השתמשתי לאוטומציה של משימות שונות. סקריפטים אלו מושלמים לכל מי שרוצה לחסוך זמן ולשפר את היעילות בשגרת העבודה שלו.

1. שינוי שם לקבצים בכמות גדולה

שינוי שם לקבצים אחד אחד יכול להיות משימה שצורכת זמן, אבל עם Python, אפשר בקלות לאוטומט את זה באמצעות המודול os.

הנה סקריפט פשוט שמבצע שינוי שם לקבצים מרובים בתיקייה על פי דפוס שניתן:

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')

סקריפט זה מחפש קבצים המכילים old_name_part בשמותיהם ומחליף אותו ב-new_name_part.

2. גיבוי קבצים באופן אוטומטי

כולנו יודעים כמה חשוב לגבות קבצים באופן קבוע, ומשימה זו יכולה להיות מאוטומטת בקלות באמצעות מודול shutil של Python.

סקריפט זה יעתיק את כל הקבצים מתיקייה אחת לאחרת לצורכי גיבוי:

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)

אתה יכול לתזמן את הסקריפט הזה לרוץ יומי באמצעות כלים לתזמון משימות כמו cron (לינוקס) או Task Scheduler (ווינדוס).

3. הורדת קבצים מהאינטרנט

אם אתה מוריד קבצים מהאינטרנט לעיתים קרובות, אז תוכל לאוטומט את המשימה הזו באמצעות ספריית aiohttp.

הנה סקריפט פשוט להורדת קבצים מ-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())

הסקריפט הזה מוריד את הקובץ מה-URL שצוין ושומר אותו בתיקיה שציינת.

4. אוטומציה של דוחות דוא"ל

אם אתה נדרש לשלוח דוחות דוא"ל באופן קבוע, תוכל לאוטומט את זה באמצעות ספריית smtplib, שמאפשרת לך לשלוח מיילים מחשבון Gmail בקלות:

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]')

הסקריפט הזה ישלח דוא"ל פשוט עם נושא ותוכן לנמען שצוין. ודא להפעיל אפליקציות פחות מאובטחות ב-Gmail אם אתה משתמש בשיטה זו.

5. מתזמן משימות (אוטומציה של משימות)

תזמון משימות יכול להתבצע בקלות באמצעות ספריית schedule, שמאפשרת לך לאוטומט משימות כמו שליחת מייל או הרצת סקריפט גיבוי בשעות מסוימות:

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)

הסקריפט הזה ימשיך לרוץ ויצית משימות בזמן שצוין, במקרה זה, 10:00 בבוקר כל יום.

6. סריקת רשת לאיסוף נתונים

שימוש ב-aiohttp עבור בקשות HTTP אסינכרוניות במקום הספרייה הסינכרונית requests יכול להפוך את תהליך גידול מידע באינטרנט ליעיל יותר.

דוגמה זו מביאה לקבלת מספר עמודים במקביל.

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. אוטומציה של פרסום ברשתות חברתיות

אם אתה מנהל חשבונות ברשתות חברתיות, תוכל לאוטומציה של הפרסום באמצעות ספריות כמו Tweepy (לטוויטר) ו־Instagram-API (לאינסטגרם) שמאפשרות לך לפרסם באופן אוטומטי.

להלן דוגמה לשימוש בספריית Tweepy לפרסום ציוץ:

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!")

סקריפט זה מפרסם ציוץ עם ההודעה "Hello, world!" בחשבון הטוויטר שלך.

8. אוטומציה של יצירת חשבוניות

אם אתה יוצר חשבוניות באופן קבוע, אפשר לאוטומציה זאת באמצעות ספריות כמו Fpdf, שתייצר חשבוניות PDF:

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)

סקריפט זה יוצר חשבונית פשוטה ושומר אותה כקובץ PDF.

9. מעקב אחר זמינות אתר אינטרנט

Python יכול לשמש לאוטומציה של מעקב אחר זמינות אתר אינטרנט באמצעות ספריית requests, שיכולה לבדוק באופן תדיר אם אתר מסוים זמין או לא:

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

סקריפט זה בודק אם האתר זמין ומדפיס את קוד המצב.

10. תגובה אוטומטית לאימיילים

אם אתה מקבל אימיילים בתדירות ורוצה להגדיר תגובה אוטומטית, ניתן להשתמש בספריות imaplib ו־smtplib כדי להשיב באופן אוטומטי לאימיילים:

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()

סקריפט זה מגיב באופן אוטומטי לאימיילים שלא נקראו עם הודעה מוגדרת מראש.

11. ניקוי קבצים

פייתון מספקת דרך יעילה לאוטומציה של ניקוי קבצים, במיוחד למחיקה או העברת קבצים ישנים לשמירה על סדר בספריות.

להלן סקריפט פשוט שמוחק קבצים שיש להם יותר ממספר ימים מסוים באמצעות מודולי os ו־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. יצירת סיסמאות באופן אוטומטי

יצירת סיסמאות חזקות וייחודיות חיונית לאבטחה, ופייתון יכולה לעזור באוטומציה של תהליך זה באמצעות מודול random.

להלן סקריפט פשוט שיוצר סיסמאות אקראיות באורך מסוים, כולל אותיות, ספרות ותווים מיוחדים לשיפור האבטחה.

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. מעקב אחר משימות/תזכורות

יצירת מעקב אחר משימות או מערכת תזכורות בפייתון ניתן להשיג באמצעות מודולים datetime ו־asyncio.

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())

סקריפט זה שולח תזכורת על המשימה בזמן מתוזמן.

14. יצירת דוחות יומיים אוטומטית

אוטומציה של דוחות יומיים על ידי שימוש בפייתון לאיסוף נתונים ועיצובם לדוח:

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. מעקב אחר משאבי המערכת

אם אתה מנהל מערכת, תוכל להשתמש בפייתון כדי לעקוב אחרי משאבי המערכת שלך כמו שימוש במעבד ובזיכרון, בעזרת ספריית psutil.

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. שינוי גודל תמונות בצורה עוקבת

אם תרצה לשנות את גודל התמונות בכמות גדולה, Python עשוי להיות הפתרון הטוב בעבורך עם הספרייה Pillow.

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))

תסריט זה משנה את גודל כל התמונות .jpg בתיקייה למימדים הצוינים.

17. אוטומציה של גיבוי נתונים לענן

גיבויים אוטומטיים לשירותי ענן כמו Google Drive הם אפשריים בעזרת Python באמצעות ספריות כמו 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. יצירת תזכורות יומיות

קביעת תזכורות יומיות קלה עם המודול time, שיזכיר לך לשתות מים כל 2 שעות:

import time

def water_reminder():
    while True:
        print("Time to drink water!")
        time.sleep(7200)  # Remind every 2 hours

water_reminder()

19. אוטומציה של קלט נתונים ל-Excel

אם אתה מזין נתונים בתדירות ל-Excel, Python יכול לעזור באוטומציה של משימה זו עם עזרת ספריית openpyxl:

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. אוטומציה של ניקוי נתונים

אם אתה עובד עם קבצי נתונים גדולים, Python יכול לאוטומציה של משימות ניקוי נתונים, שיסיר שורות ריקות מקובץ CSV:

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. חילוץ טקסט מתמונות

Python יכול לשמש לחילוץ טקסט מתמונות בעזרת ספריית pytesseract, שיכולה להיות שימושית כאשר תרצה לדיגיטל תוכן מודפס או לחלץ טקסט ממסמכים סרוקים.

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)

מסקנה

אלה רק דוגמאות מועטות למה ש- Python יכול לעשות על מנת לאוטומציה של המשימות היומיות שלך. עם התחביר הפשוט שלו והספריות העוצמתיות, Python יכול להתמודד עם כמעט כל משימה שתזרים לו.

בין אם אתה ניהול קבצים, שליחת דואר אלקטרוני, או יצירת דוחות, Python יכול לחסוך לך זמן ולשפר את היציבות שלך. אז תתחיל עם אוטומציה ב-Python היום, ותן לו לטפל במטלות היומיומיות שלך!