一文总结17个工作必备的Python自动化代码

# python script to sort files in a directory by their extension
import os
fromshutil import move
defsort_files(directory_path):
for filename in os.listdir(directory_path):
if os.path.isfile(os.path.join(directory_path, filename)):
file_extension = filename.split('.')[-1]
destination_directory = os.path.join(directory_path, file_extension)
ifnot os.path.exists(destination_directory):
os.makedirs(destination_directory)
move(os.path.join(directory_path, filename), os.path.join(destination_directory, filename))

# python script to remove empty folders in a directory
import os
defremove_empty_folders(directory_path):
for root, dirs, files in os.walk(directory_path, topdown=false):
for folder in dirs:
folder_path = os.path.join(root, folder)
ifnot os.listdir(folder_path):
                os.rmdir(folder_path)

# python script to rename multiple files in a directory
import os
defrename_files(directory_path, old_name, new_name):
for filename in os.listdir(directory_path):
if old_name in filename:
            new_filename = filename.replace(old_name, new_name)
            os.rename(os.path.join(directory_path,filename),os.path.join(directory_path, new_filename))

# python script for web scraping to extract data from a website
import requests
from bs4 import beautifulsoup
defscrape_data(url):
    response = requests.get(url)
    soup = beautifulsoup(response.text, 'html.parser')
# your code here to extract relevant data from the website

# python script to download images in bulk from a website
import requests
defdownload_images(url, save_directory):
    response = requests.get(url)
if response.status_code == 200:
        images = response.json() # assuming the api returns a json array of image urls
for index, image_url in enumerate(images):
            image_response = requests.get(image_url)
if image_response.status_code == 200:
with open(f"{save_directory}/image_{index}.jpg", "wb") as f:
                    f.write(image_response.content)

# python script to automate form submissions on a website
import requests
defsubmit_form(url, form_data):
    response = requests.post(url, data=form_data)
if response.status_code == 200:
# your code here to handle the response after form submission

# python script to count words in a text file
defcount_words(file_path):
with open(file_path, 'r') as f:
        text = f.read()
        word_count = len(text.split())
return word_count

# python script to find and replace text in a file
deffind_replace(file_path, search_text, replace_text):
with open(file_path, 'r') as f:
        text = f.read()
        modified_text = text.replace(search_text, replace_text)
with open(file_path, 'w') as f:
        f.write(modified_text)

# python script to generate random text
import random
import string
def generate_random_text(length):
    letters = string.ascii_letters + string.digits + string.punctuation
    random_text = ''.join(random.choice(letters) for i inrange(length))
    return random_text

# python script to send personalized emails to a list of recipients
import smtplib
from email.mime.text import mimetext
from email.mime.multipart import mimemultipart
defsend_personalized_email(sender_email, sender_password, recipients, subject, body):
    server = smtplib.smtp('smtp.gmail.com', 587)
    server.starttls()
    server.login(sender_email, sender_password)
for recipient_email in recipients:
        message = mimemultipart()
        message['from'] = sender_email
        message['to'] = recipient_email
        message['subject'] = subject
        message.attach(mimetext(body, 'plain'))
        server.sendmail(sender_email, recipient_email, message.as_string())
    server.quit()

# python script to send emails with file attachments
import smtplib
from email.mime.multipart import mimemultipart
from email.mime.base import mimebase
from email import encoders
defsend_email_with_attachment(sender_email,sender_password, recipient_email, subject, body, file_path):
    server = smtplib.smtp('smtp.gmail.com', 587)
    server.starttls()
    server.login(sender_email, sender_password)
    message = mimemultipart()
    message['from'] = sender_email
    message['to'] = recipient_email
    message['subject'] = subject
    message.attach(mimetext(body, 'plain'))
with open(file_path, "rb") as attachment:
        part = mimebase('application', 'octet-stream')
        part.set_payload(attachment.read())
        encoders.encode_base64(part)
        part.add_header('content-disposition', f"attachment; filename= {file_path}")
        message.attach(part)
    server.sendmail(sender_email, recipient_email, message.as_string())
    server.quit()

# python script to send automatic email reminders
import smtplib
from email.mime.text import mimetext
from datetime import datetime, timedelta
defsend_reminder_email(sender_email, sender_password, recipient_email, subject, body, reminder_date):
    server = smtplib.smtp('smtp.gmail.com', 587)
    server.starttls()
    server.login(sender_email, sender_password)
    now = datetime.now()
    reminder_date = datetime.strptime(reminder_date, '%y-%m-%d')
if now.date() == reminder_date.date():
        message = mimetext(body, 'plain')
        message['from'] = sender_email
        message['to'] = recipient_email
        message['subject'] = subject
        server.sendmail(sender_email, recipient_email, message.as_string())
    server.quit()

# python script to read and write data to an excel spreadsheet
import pandas as pd
defread_excel(file_path):
    df = pd.read_excel(file_path)
return df
defwrite_to_excel(data, file_path):
    df = pd.dataframe(data)
    df.to_excel(file_path, index=false)

# python script for data analysis and visualization with pandas and matplotlib
import pandas as pd
import matplotlib.pyplot as plt
defanalyze_and_visualize_data(data):
# your code here for data analysis and visualization
pass

# python script to merge multiple excel sheets into a single sheet
import pandas as pd
defmerge_sheets(file_path, output_file_path):
    xls = pd.excelfile(file_path)
    df = pd.dataframe()
for sheet_name in xls.sheet_names:
        sheet_df = pd.read_excel(xls, sheet_name)
        df = df.append(sheet_df)
        df.to_excel(output_file_path, index=false)

# python script to connect to a database and execute queries
import sqlite3
defconnect_to_database(database_path):
    connection = sqlite3.connect(database_path)
return connection
defexecute_query(connection, query):
    cursor = connection.cursor()
    cursor.execute(query)
    result = cursor.fetchall()
return result

# python script to execute sql queries on a database
importsqlite3
defexecute_query(connection, query):
cursor = connection.cursor()
cursor.execute(query)
result = cursor.fetchall()
returnresult

import shutil
defbackup_database(database_path, backup_directory):
    shutil.copy(database_path, backup_directory)
defrestore_database(backup_path, database_directory):
    shutil.copy(backup_path, database_directory)

# python script to automate posting on twitter and facebook
from twython import twython
import facebook
defpost_to_twitter(api_key, api_secret, access_token, access_token_secret, message):
    twitter = twython(api_key, api_secret, access_token, access_token_secret)
    twitter.update_status(status=message)
defpost_to_facebook(api_key, api_secret, access_token, message):
    graph = facebook.graphapi(access_token)
    graph.put_object(parent_object='me', connection_name='feed', message=message)

# python script to automatically share content on social media platforms
import random
defget_random_content():
# your code here to retrieve random content from a list or database
pass
defpost_random_content_to_twitter(api_key, api_secret, access_token, access_token_secret):
content = get_random_content()
post_to_twitter(api_key, api_secret, access_token, access_token_secret, content)
defpost_random_content_to_facebook(api_key, api_secret, access_token):
content = get_random_content()
post_to_facebook(api_key, api_secret, access_token, content)

# python script for scraping data from social media platforms
import requests
defscrape_social_media_data(url):
    response = requests.get(url)
# your code here to extract relevant data from the response

# python script to manage system processes
import psutil
defget_running_processes():
return [p.info for p in psutil.process_iter(['pid', 'name', 'username'])]
defkill_process_by_name(process_name):
for p in psutil.process_iter(['pid', 'name', 'username']):
if p.info['name'] == process_name:
p.kill()

# python script to schedule tasks using cron syntax
from crontab import crontab
defschedule_task(command, schedule):
cron = crontab(user=true)
job = cron.new(command=command)
job.setall(schedule)
cron.write()

# python script to monitor disk space and send an alert if it's low
import psutil
defcheck_disk_space(minimum_threshold_gb):
disk = psutil.disk_usage('/')
free_space_gb = disk.free / (230) # convert bytes to gb
if free_space_gb < minimum_threshold_gb:
# your code here to send an alert (email, notification, etc.)
pass

# python script to resize and crop images
from pil import image
defresize_image(input_path, output_path, width, height):
    image = image.open(input_path)
    resized_image = image.resize((width, height), image.antialias)
    resized_image.save(output_path)
defcrop_image(input_path, output_path, left, top, right, bottom):
    image = image.open(input_path)
    cropped_image = image.crop((left, top, right, bottom))
    cropped_image.save(output_path)

# python script to add watermarks to images
from pil import image
from pil import imagedraw
from pil import imagefont
defadd_watermark(input_path, output_path, watermark_text):
image = image.open(input_path)
draw = imagedraw.draw(image)
font = imagefont.truetype('arial.ttf', 36)
draw.text((10, 10), watermark_text, fill=(255, 255, 255, 128), font=font)
image.save(output_path)

# python script to create image thumbnails
from pil import image
defcreate_thumbnail(input_path, output_path, size=(128, 128)):
image = image.open(input_path)
image.thumbnail(size)
image.save(output_path)

# python script to check the status of a website
import requests
defcheck_website_status(url):
response = requests.get(url)
if response.status_code == 200:
# your code here to handle a successful response
else:
# your code here to handle an unsuccessful response

# python script to automate ftp file transfers
from ftplib import ftp
defftp_file_transfer(host, username, password, local_file_path, remote_file_path):
with ftp(host) as ftp:
ftp.login(user=username, passwd=password)
with open(local_file_path, 'rb') as f:
ftp.storbinary(f'stor {remote_file_path}', f)

# python script to automate network device configuration
from netmiko import connecthandler
defconfigure_network_device(host, username, password, configuration_commands):
device = {
'device_type': 'cisco_ios',
'host': host,
'username': username,
'password': password,}
with connecthandler(device) as net_connect:
net_connect.send_config_set(configuration_commands)

# python script to remove duplicates from data
import pandas as pd
defremove_duplicates(data_frame):
cleaned_data = data_frame.drop_duplicates()
return cleaned_data

# python script for data normalization
import pandas as pd
defnormalize_data(data_frame):
normalized_data = (data_frame - data_frame.min()) / (data_frame.max() -  data_frame.min())
return normalized_data

# python script to handle missing values in data
import pandas as pd
defhandle_missing_values(data_frame):
filled_data = data_frame.fillna(method='ffill')
return filled_data

# python script to extract text from pdfs
importpypdf2
def extract_text_from_pdf(file_path):
withopen(file_path, 'rb') as f:
pdf_reader = pypdf2.pdffilereader(f)
text = ''
for page_num inrange(pdf_reader.numpages):
page = pdf_reader.getpage(page_num)
text += page.extracttext()
returntext

# python script to merge multiple pdfs into a single pdf
import pypdf2
defmerge_pdfs(input_paths, output_path):
pdf_merger = pypdf2.pdfmerger()
for path in input_paths:
with open(path, 'rb') as f:
pdf_merger.append(f)
with open(output_path, 'wb') as f:
pdf_merger.write(f)

# python script to add password protection to a pdf
import pypdf2
defadd_password_protection(input_path, output_path, password):
with open(input_path, 'rb') as f:
pdf_reader = pypdf2.pdffilereader(f)
pdf_writer = pypdf2.pdffilewriter()
for page_num in range(pdf_reader.numpages):
page = pdf_reader.getpage(page_num)
pdf_writer.addpage(page)
pdf_writer.encrypt(password)
with open(output_path, 'wb') as output_file:
pdf_writer.write(output_file)

# python script for gui automation using pyautogui
import pyautogui
defautomate_gui():
# your code here for gui automation using pyautogui
pass

# python script to create simple gui applications using tkinter
import tkinter as tk
defcreate_simple_gui():
# your code here to define the gui elements and behavior
pass

# python script to handle gui events using tkinter
import tkinter as tk
defhandle_gui_events():
pass
defon_button_click():
# your code here to handle button click event
root = tk.tk()
button = tk.button(root, text="click me", command=on_button_click)
button.pack()
root.mainloop()

# python script for unit testing with the unittest module
import unittest
defadd(a, b):
return a + b
classtestaddfunction(unittest.testcase):
deftest_add_positive_numbers(self):
self.assertequal(add(2, 3), 5)
deftest_add_negative_numbers(self):
self.assertequal(add(-2, -3), -5)
deftest_add_zero(self):
self.assertequal(add(5, 0), 5)
if __name__ == '__main__':
unittest.main()

# python script for web testing using selenium
from selenium import webdriver
defperform_web_test():
driver = webdriver.chrome()
driver.get("https://www.example.com")
# your code here to interact with web elements and perform tests
driver.quit()

# python script for building test automation frameworks
# your code here to define the framework architecture and tools

# python script to automate uploading files to cloud storage
# your code here to connect to a cloud storage service (e.g., aws s3, google cloud storage)
# your code here to upload files to the cloud storage

# python script to manage aws resources using boto3
import boto3
def create_ec2_instance(instance_type, image_id, key_name, security_group_ids):
ec2 = boto3.resource('ec2')
instance = ec2.create_instances(
imageid=image_id,
instancetype=instance_type,
keyname=key_name,
securitygroupids=security_group_ids,
mincount=1,
maxcount=1)
return instance[0].id 

# python script to automate interactions with google drive
# your code here to connect to google drive using the respective api
# your code here to perform tasks such as uploading files, creating folders, etc.

# python script for stock price analysis
# your code here to fetch stock data using a financial api (e.g., yahoo finance)
# your code here to analyze the data and derive insights

# python script to fetch currency exchange rates
# your code here to connect to a currency exchange api (e.g., fixer.io, open exchange rates)
# your code here to perform currency conversions and display exchange rates

# python script for budget tracking and analysis
# your code here to read financial transactions from a csv or excel file
# your code here to calculate income, expenses, and savings
# your code here to generate reports and visualize budget data

# python script for sentiment analysis using nltk or other nlp libraries
importnltk
fromnltk.sentiment import sentimentintensityanalyzer
defanalyze_sentiment(text):
nltk.download('vader_lexicon')
sia = sentimentintensityanalyzer()
sentiment_score = sia.polarity_scores(text)
return sentiment_score

# python script for text summarization using nlp techniques
# your code here to read the text data and preprocess it (e.g., removing stop words)
# your code here to generate the summary using techniques like tf-idf, textrank, or bert

# python script for language translation using nlp libraries
# your code here to connect to a translation api (e.g., google translate, microsoft translator)
# your code here to translate text between different languages