Python 30个自动化日常任务脚本：职场效率提升利器

import csv

def clean_csv(input_file, output_file):
    with open(input_file, mode='r', newline='', encoding='utf-8') as infile, \
         open(output_file, mode='w', newline='', encoding='utf-8') as outfile:
        reader = csv.reader(infile)
        writer = csv.writer(outfile)
        for row in reader:
            cleaned_row = [cell.strip() for cell in row]
            writer.writerow(cleaned_row)

input_file = '/path/to/input.csv'
output_file = '/path/to/cleaned_output.csv'
clean_csv(input_file, output_file)

import os

def count_files_and_dirs(directory):
    total_files = 0
    total_dirs = 0
    for root, dirs, files in os.walk(directory):
        total_files += len(files)
        total_dirs += len(dirs)
    return total_files, total_dirs

directory = '/path/to/your/directory'
files, dirs = count_files_and_dirs(directory)
print(f"Total files: {files}, Total directories: {dirs}")

import os

def classify_files_by_type(directory):
    file_types = {}
    for filename in os.listdir(directory):
        if os.path.isfile(os.path.join(directory, filename)):
            extension = os.path.splitext(filename)[1]
            if extension in file_types:
                file_types[extension] += 1
            else:
                file_types[extension] = 1
    return file_types

directory = '/path/to/your/directory'
file_types = classify_files_by_type(directory)
for ext, count in file_types.items():
    print(f"Files with extension '{ext}': {count}")

from PIL import Image
from pytesseract import pytesseract

def image_to_text(image_path):
    img = Image.open(image_path)
    text = pytesseract.image_to_string(img)
    return text

image_path = '/path/to/your/image.png'
text = image_to_text(image_path)
print(f"Text from image: {text}")

from moviepy.editor import VideoFileClip

def convert_video_to_audio(video_path, audio_path):
    clip = VideoFileClip(video_path)
    clip.audio.write_audiofile(audio_path)

video_path = '/path/to/your/video.mp4'
audio_path = '/path/to/converted/audio.mp3'
convert_video_to_audio(video_path, audio_path)

import requests
from bs4 import BeautifulSoup
import os

def extract_images_from_webpage(url, output_dir):
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    images = soup.find_all('img')
    os.makedirs(output_dir, exist_ok=True)
    for image in images:
        src = image.get('src')
        if src and src.startswith('http'):
            image_data = requests.get(src).content
            filename = os.path.join(output_dir, os.path.basename(src))
            with open(filename, 'wb') as f:
                f.write(image_data)

url = ' https://example.com '
output_dir = '/path/to/output/images'
extract_images_from_webpage(url, output_dir)

from deep_translator import GoogleTranslator

def translate_text(input_file, output_file, target_language):
    with open(input_file, 'r', encoding='utf-8') as file:
        text = file.read()
    translated_text = GoogleTranslator(source='auto', target=target_language).translate(text)
    with open(output_file, 'w', encoding='utf-8') as file:
        file.write(translated_text)

input_file = '/path/to/your/text.txt'
output_file = '/path/to/translated_text.txt'
target_language = 'es'  # 西班牙语
translate_text(input_file, output_file, target_language)

from transformers import pipeline

def generate_summary(text):
    summarizer = pipeline("summarization")
    summary = summarizer(text, max_length=130, min_length=30, do_sample=False)
    return summary[0]['summary_text']

text = """Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Sed non risus. Suspendisse lectus tortor, dignissim sit amet, adipiscing nec, ultricies sed, dolor."""
summary = generate_summary(text)
print(f"Summary: {summary}")

import shutil
import os

def sync_folders(src_folder, dst_folder):
    for item in os.listdir(src_folder):
        s = os.path.join(src_folder, item)
        d = os.path.join(dst_folder, item)
        if os.path.isdir(s):
            shutil.copytree(s, d, dirs_exist_ok=True)
        else:
            shutil.copy2(s, d)

src_folder = '/path/to/source/folder'
dst_folder = '/path/to/destination/folder'
sync_folders(src_folder, dst_folder)

import boto3

def upload_to_s3(bucket_name, local_file_path, remote_file_path):
    s3 = boto3.client('s3')
    s3.upload_file(local_file_path, bucket_name, remote_file_path)

bucket_name = 'your-bucket-name'
local_file_path = '/path/to/your/local/file'
remote_file_path = 'path/to/remote/file'
upload_to_s3(bucket_name, local_file_path, remote_file_path)

import os

def batch_rename(directory, prefix):
    for i, filename in enumerate(os.listdir(directory)):
        os.rename(
            os.path.join(directory, filename),
            os.path.join(directory, f"{prefix}_{i}{os.path.splitext(filename)[1]}")
        )

directory = '/path/to/files'
prefix = 'new_name'
batch_rename(directory, prefix)

import smtplib
from email.mime.text import MIMEText

def send_email(subject, body, to_email):
    msg = MIMEText(body)
    msg['Subject'] = subject
    msg['From'] = 'your_email@example.com'
    msg['To'] = to_email
    
    with smtplib.SMTP('smtp.example.com', 587) as server:
        server.starttls()
        server.login('your_email@example.com', 'your_password')
        server.send_message(msg)

send_email('Test Subject', 'This is the email body', 'recipient@example.com')

import requests
import time

def monitor_website(url, check_interval=60):
    previous_content = requests.get(url).text
    while True:
        time.sleep(check_interval)
        current_content = requests.get(url).text
        if current_content != previous_content:
            print("Website content has changed!")
            previous_content = current_content

monitor_website(' https://example.com ')

from selenium import webdriver

def auto_fill_form(url, form_data):
    driver = webdriver.Chrome()
    driver.get(url)
    
    for field_name, value in form_data.items():
        element = driver.find_element_by_name(field_name)
        element.send_keys(value)
    
    submit_button = driver.find_element_by_xpath("//input[@type='submit']")
    submit_button.click()

form_data = {
    'username': 'your_username',
    'password': 'your_password'
}
auto_fill_form(' https://example.com/login ', form_data)

from docx import Document

def generate_report(title, content, output_file):
    doc = Document()
    doc.add_heading(title, level=1)
    doc.add_paragraph(content)
    doc.save(output_file)

generate_report('Monthly Report', 'This is the report content...', 'monthly_report.docx')

import tweepy

def tweet_message(api_key, api_secret, access_token, access_token_secret, message):
    auth = tweepy.OAuthHandler(api_key, api_secret)
    auth.set_access_token(access_token, access_token_secret)
    api = tweepy.API(auth)
    api.update_status(message)

tweet_message('your_api_key', 'your_api_secret', 
              'your_access_token', 'your_access_token_secret',
              'Hello from Python!')

import speech_recognition as sr

def transcribe_meeting(audio_file):
    r = sr.Recognizer()
    with sr.AudioFile(audio_file) as source:
        audio = r.record(source)
    try:
        return r.recognize_google(audio)
    except Exception as e:
        return f"Error: {str(e)}"

transcription = transcribe_meeting('meeting_recording.wav')
with open('meeting_transcript.txt', 'w') as f:
    f.write(transcription)

import pandas as pd
import matplotlib.pyplot as plt

def auto_visualize(data_file):
    df = pd.read_csv(data_file)
    df.plot(kind='bar')
    plt.savefig('visualization.png')

auto_visualize('data.csv')

from cryptography.fernet import Fernet
import json

def generate_key():
    return Fernet.generate_key()

def encrypt_password(key, password):
    f = Fernet(key)
    return f.encrypt(password.encode()).decode()

def decrypt_password(key, encrypted_password):
    f = Fernet(key)
    return f.decrypt(encrypted_password.encode()).decode()

key = generate_key()
encrypted = encrypt_password(key, "my_secret_password")
print(decrypt_password(key, encrypted))

import psutil
import time

def monitor_resources(interval=5):
    while True:
        cpu = psutil.cpu_percent()
        memory = psutil.virtual_memory().percent
        print(f"CPU Usage: {cpu}%, Memory Usage: {memory}%")
        time.sleep(interval)

monitor_resources()

import os

def rename_files(directory, prefix):
    for filename in os.listdir(directory):
        file_path = os.path.join(directory, filename)
        if os.path.isfile(file_path):
            new_filename = f"{prefix}_{filename}"
            new_file_path = os.path.join(directory, new_filename)
            os.rename(file_path, new_file_path)
            print(f"Renamed '{filename}' to '{new_filename}'")

# 示例用法
rename_files('/path/to/your/files', 'project')

import os
import shutil

def organize_folder(folder_path):
    file_types = {
        "Images": [".jpg", ".jpeg", ".png", ".gif"],
        "Documents": [".pdf", ".docx", ".txt"],
        "Spreadsheets": [".xlsx", ".csv"],
        "Videos": [".mp4", ".mov", ".avi"]
    }
    for file_name in os.listdir(folder_path):
        file_path = os.path.join(folder_path, file_name)
        if os.path.isfile(file_path):
            file_ext = os.path.splitext(file_name)[1].lower()
            for folder, extensions in file_types.items():
                if file_ext in extensions:
                    target_folder = os.path.join(folder_path, folder)
                    os.makedirs(target_folder, exist_ok=True)
                    shutil.move(file_path, os.path.join(target_folder, file_name))
                    break

import os
import shutil
import datetime
import zipfile

def backup_files(src_dir, backup_dir):
    current_time = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    backup_name = f"backup_{current_time}"
    backup_path = os.path.join(backup_dir, backup_name)
    
    if not os.path.exists(backup_dir):
        os.makedirs(backup_dir)
    
    with zipfile.ZipFile(backup_path + '.zip', 'w', zipfile.ZIP_DEFLATED) as zipf:
        for root, _, files in os.walk(src_dir):
            for file in files:
                file_path = os.path.join(root, file)
                arc_name = os.path.relpath(file_path, src_dir)
                zipf.write(file_path, arc_name)
    
    print(f"备份完成!文件保存在: {backup_path}.zip")

import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

def send_email(subject, body, recipient):
    sender_email = "your_email@gmail.com"
    sender_password = "your_password"
    
    message = MIMEMultipart()
    message["From"] = sender_email
    message["To"] = recipient
    message["Subject"] = subject
    message.attach(MIMEText(body, "plain"))
    
    with smtplib.SMTP("smtp.gmail.com", 587) as server:
        server.starttls()
        server.login(sender_email, sender_password)
        server.send_message(message)
    
    print("Email sent!")

import requests
from bs4 import BeautifulSoup

def fetch_headlines(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    headlines = soup.find_all('h2')
    for i, headline in enumerate(headlines[:5]):
        print(f"{i+1}. {headline.text.strip()}")

# 示例用法
fetch_headlines(" https://news.ycombinator.com/ ")

import webbrowser

def open_websites():
    urls = [
        " https://mail.google.com ",
        " https://www.jira.com ",
        " https://www.github.com "
    ]
    for url in urls:
        webbrowser.open(url)

# 示例用法
open_websites()

def replace_text_in_file(file_path, old_text, new_text):
    with open(file_path, 'r+') as file:
        content = file.read()
        new_content = content.replace(old_text, new_text)
        file.seek(0)
        file.write(new_content)
        file.truncate()

# 示例用法
replace_text_in_file('/your/text.txt', 'old_word', 'new_word')

import os
import shutil
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
from datetime import datetime

class FileBackupHandler(FileSystemEventHandler):
    def __init__(self, source_dir, backup_dir):
        self.source_dir = source_dir
        self.backup_dir = backup_dir
    
    def on_modified(self, event):
        if not event.is_directory:
            self.copy_file(event.src_path)
    
    def copy_file(self, src):
        timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
        backup_path = os.path.join(self.backup_dir, f"backup_{timestamp}")
        os.makedirs(backup_path, exist_ok=True)
        shutil.copy2(src, backup_path)

def monitor_folder(source_dir, backup_dir):
    event_handler = FileBackupHandler(source_dir, backup_dir)
    observer = Observer()
    observer.schedule(event_handler, source_dir, recursive=True)
    observer.start()
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()

import schedule
import time

def job():
    print("Job running...")

# 设置定时任务
schedule.every(1).minutes.do(job)
schedule.every().day.at("10:30").do(job)

while True:
    schedule.run_pending()
    time.sleep(1)

import tweepy

def post_tweet(api_key, api_secret, access_token, access_secret, message):
    auth = tweepy.OAuthHandler(api_key, api_secret)
    auth.set_access_token(access_token, access_secret)
    api = tweepy.API(auth)
    api.update_status(message)

# 示例用法
post_tweet("API_KEY", "API_SECRET", "ACCESS_TOKEN", "ACCESS_SECRET", "Hello, Twitter!")