10 个令人惊叹的 Python 自动化脚本！

                                                                        /01/ 剪贴板管理器

你是否曾发现自己忙于处理多个文本片段，而忘记了自己复制了什么？有没有想过有一个工具可以记录你一天中复制的所有内容？

这个自动化脚本可以监控你复制的所有内容，将复制的每个文本无缝地存储在一个时尚的图形界面中，这样你就不必在无尽的标签页中搜索，也不会丢失一些有价值的信息。

该自动化脚本利用Pyperclip库的强大功能无缝捕获复制数据，并集成了Tkinter以可视化方式跟踪和管理复制的文本。

import tkinter as tk
from tkinter import ttk
import pyperclip

def update_listbox():
    new_item = pyperclip.paste()
    if new_item not in X:
        X.append(new_item)
        listbox.insert(tk.END, new_item)
        listbox.insert(tk.END, "----------------------")
    listbox.yview(tk.END)
    root.after(1000, update_listbox)

def copy_to_clipboard(event):
    selected_item = listbox.get(listbox.curselection())
    if selected_item:
        pyperclip.copy(selected_item)

X = []

root = tk.Tk()
root.title("Clipboard Manager")
root.geometry("500x500")
root.configure(bg="#f0f0f0")

frame = tk.Frame(root, bg="#f0f0f0")
frame.pack(padx=10, pady=10)

label = tk.Label(frame, text="Clipboard Contents:", bg="#f0f0f0")
label.grid(row=0, column=0)

scrollbar = tk.Scrollbar(root)
scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

listbox = tk.Listbox(root, width=150, height=150, yscrollcommand=scrollbar.set)
listbox.pack(pady=10)
scrollbar.config(command=listbox.yview)

update_listbox()

listbox.bind("<Double-Button-1>", copy_to_clipboard)

root.mainloop()

                                                                /02/ 代码质量检查器

每个开发人员都会遇到这样的挫折：在 Python 代码中查找错误，却发现自己迷失在错误的迷宫中。作为开发人员，我们深知编写简洁高效代码的重要性，但手动分析代码质量可能是一项压力巨大的任务。

本自动化脚本利用 Pylint 和 Flake8 Python 软件包对代码质量进行全面审查。将你的代码与编码标准进行比较，并找出逻辑错误。它可确保的代码符合行业最佳实践并保持无错。

import os
import subprocess

def analyze_code(directory):
    # List Python files in the directory
    python_files = [file for file in os.listdir(directory) if file.endswith('.py')]

    if not python_files:
        print("No Python files found in the specified directory.")
        return

    # Analyze each Python file using pylint and flake8
    for file in python_files:
        print(f"Analyzing file: {file}")
        file_path = os.path.join(directory, file)

        # Run pylint
        print("\nRunning pylint...")
        pylint_command = f"pylint {file_path}"
        subprocess.run(pylint_command, shell=True)

        # Run flake8
        print("\nRunning flake8...")
        flake8_command = f"flake8 {file_path}"
        subprocess.run(flake8_command, shell=True)

if __name__ == "__main__":
    directory = r"C:\Users\abhay\OneDrive\Desktop\Part7"
    analyze_code(directory)

对一个旧 Python 脚本进行代码质量审查时的输出结果，该脚本通过网络应用程序将文件转换为不同格式

                                                                /03/ 不篡改文件

文件篡改又称数据篡改，是指未经授权故意更改信息，包括破坏、篡改或编辑数据。

全球许多威胁行为者滥用文件篡改技术，在关键系统文件中引入不同的漏洞或后门，从而危及安全性并使未经授权的访问成为可能。

要降低这种风险，关键是要验证文件的完整性，确保它们与原始状态保持一致。这个自动化脚本可以帮助你测试任何文件，并识别其是否被篡改。

import hashlib
import os

def calculate_sha256(file_path):
    sha256 = hashlib.sha256()
    with open(file_path, 'rb') as file:
        for chunk in iter(lambda: file.read(4096), b''):
            sha256.update(chunk)
    return sha256.hexdigest()

def check_integrity(file_path, expected_checksum):
    actual_checksum = calculate_sha256(file_path)
    return actual_checksum == expected_checksum

if __name__ == "__main__":
    file_path = input("Enter the path to the file: ")
    expected_checksum = input("Enter the expected SHA-256 checksum: ")

    if os.path.isfile(file_path):
        if check_integrity(file_path, expected_checksum):
            print("File integrity verified: The file has not been tampered with.")
        else:
            print("File integrity check failed: The file may have been tampered with.")
    else:
        print("Error: File not found.")

使用样本 ZIP 文件（未篡改）进行脚本测试

使用样本 ZIP 文件（篡改）进行脚本测试

                                                                        /04/ 智能交易

交易是指买卖股票、债券、货币、商品或衍生品等金融工具，以获取利润。期刊交易员整天都在查看不同的仪表盘，试图找出买入或卖出的完美决策。

这个自动化脚本可以帮助交易者和投资者很好地了解你愿意投资的任何股票。它利用*****Prophet* Python 库，根据从雅虎财经获取的历史股票数据预测近期股票价格。

import streamlit as st
from datetime import date

import yfinance as yf
from prophet import Prophet
from prophet.plot import plot_plotly
from plotly import graph_objs as go

START = "2015-01-01"
TODAY = date.today().strftime("%Y-%m-%d")

st.title('Stock Forecast App')

stocks = ('MSFT',"TSLA",'GOOG', 'AAPL', "NVDA")
selected_stock = st.selectbox('Select dataset for prediction', stocks)

n_years = st.slider('Years of prediction:', 1, 4)
period = n_years * 365


@st.cache
def load_data(ticker):
    data = yf.download(ticker, START, TODAY)
    data.reset_index(inplace=True)
    return data

 
data_load_state = st.text('Loading data...')
data = load_data(selected_stock)
data_load_state.text('Loading data... done!')

st.subheader('Raw data')
st.write(data.tail())

# Plot raw data
def plot_raw_data():
 fig = go.Figure()
 fig.add_trace(go.Scatter(x=data['Date'], y=data['Open'], name="stock_open"))
 fig.add_trace(go.Scatter(x=data['Date'], y=data['Close'], name="stock_close"))
 fig.layout.update(title_text='Time Series data with Rangeslider', xaxis_rangeslider_visible=True)
 st.plotly_chart(fig)
 
plot_raw_data()

# Predict forecast with Prophet.
df_train = data[['Date','Close']]
df_train = df_train.rename(columns={"Date": "ds", "Close": "y"})

m = Prophet()
m.fit(df_train)
future = m.make_future_dataframe(periods=period)
forecast = m.predict(future)

# Show and plot forecast
st.subheader('Forecast data')
st.write(forecast.tail())
    
st.write(f'Forecast plot for {n_years} years')
fig1 = plot_plotly(m, forecast)
st.plotly_chart(fig1)

st.write("Forecast components")
fig2 = m.plot_components(forecast)
st.write(fig2)

要运行此程序，首先需要使用 pip 安装 Streamlit、yfinance、prophet 和 plotly python 库。

pip install streamlit prophet yfinance plotly

然后使用命令streamlit run smart_trade.py 运行它

"使用我们的 Streamlit 应用程序预测 NVDA 股票" - Nvidia 股票在未来几年似乎会上涨，这证明它是今天值得买入的好股票

                                                                /05/ 自动图像下载器

收集图像数据是计算机视觉项目的关键挑战。正如 Andrew Ng 所说，如果你能收集到大量数据集，那么算法就不重要了。数据对提高模型的性能和准确性起着关键作用。

只需几行代码，这个自动化脚本就能帮助你在几分钟内从网上下载数据

# Importing the necessary module and function
from simple_image_download import simple_image_download as simp 

# Creating a response object
response = simp.simple_image_download

## Keyword
keyword = "Dog"

# Downloading images
try:
    response().download(keyword, 20)
    print("Images downloaded successfully.")
except Exception as e:
    print("An error occurred:", e)

                                                                /06/ 端口扫描程序

在计算机网络中，端口是允许不同进程或服务通过网络连接和交换数据的通信端点。端口由数值标识，并与特定协议相关联。

开放端口就像建筑物中的门窗，每个端口都是网站与外部网络通信的潜在入口。然而，在没有采取适当安全措施的情况下开放端口，会使网站容易受到网络攻击。

这个自动化脚本会将网站 URL 作为输入，并检查该网站是否存在任何开放端口。无论你是作为 "红队 "的一员在执行任务，还是在 "蓝队 "中坚守阵地，这个脚本都能为你提供有用的便利工具。

import socket
from prettytable import PrettyTable

# Dictionary mapping common ports to vulnerabilities (Top 15)
vulnerabilities = {
    80: "HTTP (Hypertext Transfer Protocol) - Used for unencrypted web traffic",
    443: "HTTPS (HTTP Secure) - Used for encrypted web traffic",
    22: "SSH (Secure Shell) - Used for secure remote access",
    21: "FTP (File Transfer Protocol) - Used for file transfers",
    25: "SMTP (Simple Mail Transfer Protocol) - Used for email transmission",
    23: "Telnet - Used for remote terminal access",
    53: "DNS (Domain Name System) - Used for domain name resolution",
    110: "POP3 (Post Office Protocol version 3) - Used for email retrieval",
    143: "IMAP (Internet Message Access Protocol) - Used for email retrieval",
    3306: "MySQL - Used for MySQL database access",
    3389: "RDP (Remote Desktop Protocol) - Used for remote desktop connections (Windows)",
    8080: "HTTP Alternate - Commonly used as a secondary HTTP port",
    8000: "HTTP Alternate - Commonly used as a secondary HTTP port",
    8443: "HTTPS Alternate - Commonly used as a secondary HTTPS port",
    5900: "VNC (Virtual Network Computing) - Used for remote desktop access",
    # Add more ports and vulnerabilities as needed
}

def display_table(open_ports):
    table = PrettyTable(["Open Port", "Vulnerability"])
    for port in open_ports:
        vulnerability = vulnerabilities.get(port, "No known vulnerabilities associated with common services")
        table.add_row([port, vulnerability])
    print(table)

def scan_top_ports(target):
    open_ports = []
    top_ports = [21, 22, 23, 25, 53, 80, 110, 143, 443, 3306, 3389, 5900, 8000, 8080, 8443]  # Top 15 ports
    for port in top_ports:
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(1)  # Adjust timeout as needed
            result = sock.connect_ex((target, port))
            if result == 0:
                open_ports.append(port)
            sock.close()
        except KeyboardInterrupt:
            sys.exit()
        except socket.error:
            pass
    return open_ports

def main():
    target = input("Enter the website URL or IP address to scan for open ports: ")
    open_ports = scan_top_ports(target)
    if not open_ports:
        print("No open ports found on the target.")
    else:
        print("Open ports and associated vulnerabilities:")
        display_table(open_ports)

if __name__ == "__main__":
    main()

使用脚本识别的 OpenPorts 列表

                                                                /07/ 密码管理器

作为一名数字自由职业者，最糟糕的事情之一就是需要记住很多密码，因为每天你都要注册一个新网站。

这个自动化脚本可以帮你管理所有密码，使用不同的加密技术确保密码安全，只有你自己才能访问。

这个脚本最棒的地方在于它是一个网络应用程序，只需稍作改动，你就可以将它部署到云存储上，随时随地访问你的所有密码，而无需担心安全问题。

import streamlit as st
import csv
from cryptography.fernet import Fernet
from cryptography.fernet import InvalidToken

# Custom encryption key (hardcoded)  
CUSTOM_ENCRYPTION_KEY = b'u7wGgNdDFefqpr_kGxb8wJf6XRVsRwvb3QgITsD5Ft4='                   ## 如果您打算在共享平台上使用此脚本，请确保将此密钥保存在一个单独的安全文件中。

# Function to encrypt password
def encrypt_password(password):
    cipher_suite = Fernet(CUSTOM_ENCRYPTION_KEY)
    encrypted_password = cipher_suite.encrypt(password.encode())
    return encrypted_password

# Function to decrypt password
def decrypt_password(encrypted_password):
    if isinstance(encrypted_password, bytes):
        try:
            cipher_suite = Fernet(CUSTOM_ENCRYPTION_KEY)
            decrypted_password = cipher_suite.decrypt(encrypted_password)
            return decrypted_password.decode()
        except InvalidToken:
            return "Invalid Token"
    else:
        return None

# Function to save website name and password to CSV file
def save_credentials(website_name, password):
    encrypted_password = encrypt_password(password)
    with open('credentials.csv', 'a', newline='') as csvfile:
        writer = csv.writer(csvfile)
        writer.writerow([website_name, encrypted_password.decode()])  # Ensure storing string representation

# Function to retrieve password from CSV file
def retrieve_password(website_name):
    with open('credentials.csv', 'r') as csvfile:
        reader = csv.reader(csvfile)
        for row in reader:
            if row[0] == website_name:
                encrypted_password = row[1].encode()
                return encrypted_password
    return None

# Streamlit UI
st.title("Password Manager")

# Input fields for website name and password
website_name = st.text_input("Enter website name:")
password = st.text_input("Enter password:", type="password")

# Save button to save website name and password
if st.button("Save"):
    if website_name and password:
        save_credentials(website_name, password)
        st.success("Website name and password saved successfully.")
    else:
        st.error("Please fill in all fields.")

# Retrieve button to retrieve password
if st.checkbox("Retrieve Password"):
    website_name = st.selectbox("Select website name:", options=[""] + [row[0] for row in csv.reader(open('credentials.csv', 'r'))])
    key = st.text_input("Enter Your Encryption Key:", type="password")
    if st.button("Retrieve Password"):
        if key == str(CUSTOM_ENCRYPTION_KEY.decode()):
            if website_name:
                encrypted_password = retrieve_password(website_name)
                if encrypted_password:
                    decrypted_password = decrypt_password(encrypted_password)
                    st.success(f"Password for **{website_name}** -> **{decrypted_password}**")
                else:
                    st.error("Password not found in database.")
        elif key == "":
            pass 
        else:
            st.error("Invalid Encryption Key!!!")

它使用硬编码的自定义密钥进行加密和解密。如果你打算在共享平台上使用此脚本，请确保将此密钥保存在一个单独的安全文件中。

正确的加密密钥

- 错误的加密密钥

/08/ 邮件群发器

电子邮件列表是在线参与的货币，每个订阅者都是您数字部落的重要成员。它们是有效数字营销的心脏。

作为一个有影响力的数字营销者，与你的追随者保持互动非常重要，但手动操作是一项艰巨的工作，而使用相关工具则需要花费大量资金。

这款自动化脚本可利用 Gmail 自带的 SMTP 服务器，在几分钟内批量发送电子邮件，让你可以完全自定义并行使权力。

import smtplib
import ssl

# SMTP server details
smtp_server = 'data.STUDIO.com'
smtp_port = 465

# Sender and recipient details
from_address = 'Winzo Shop'
to_address = ['','']     ## Recepients List

# Authentication details
username = ''       ## Sender Email
password = ''       ## Sender Password


# Email message details
subject = '

标签：10,令人惊叹,Python,st,file,import,path,password,name	

From： https://blog.csdn.net/m0_66995023/article/details/141563869