创作不易，方便的话点点关注，谢谢
文章结尾有最新热度的文章，感兴趣的可以去看看。
本文是经过严格查阅相关权威文献和资料，形成的专业的可靠的内容。全文数据都有据可依，可回溯。特别申明：数据和资料已获得授权。本文内容，不涉及任何偏颇观点，用中立态度客观事实描述事情本身
文章有点长(9100字阅读时间：20分)，期望您能坚持看完，并有所收获。
导读
自动化是现代创新的核心，它彻底改变了我们应对日常挑战和复杂工作流程的方式。Python 是一种动态编程语言，以其强大的库生态系统、直观的设计和不断扩大的创新者社区而闻名。无论您是想简化重复性任务，还是想制作复杂的解决方案，Python 都是提高效率的终极助推器。在本博客中，我们将介绍 9个非常有用的自动化脚本，您需要尝试使用 Python。
1、Inspectra（您的随身代码质量检查器）
该自动化脚本使用 Black、Flake8 和 Bandit 库，通过将代码与定义明确的编码标准进行比较，扫描代码目录中的任何逻辑或衬垫错误。它不仅能扫描代码，还能生成日志，供您日后参考并改进代码库标准。
import os
import subprocess
defanalyze_code(directory):
# List Python files in the directory
python_files =[file for file in os.listdir(directory)if file.endswith('.py')]
ifnot python_files:
print("No Python files found in the specified directory.")
return
report_dir = os.path.join(directory,"reports")
os.makedirs(report_dir, exist_ok=True)
for file in python_files:
print(f"Analyzing file: {file}")
file_path = os.path.join(directory, file)
# Run Black (code formatter)
print("\nRunning Black...")
black_command =f"black {file_path} --check"
subprocess.run(black_command, shell=True)
# Run Flake8 (linter)
print("\nRunning Flake8...")
flake8_output_file = os.path.join(report_dir,f"{file}_flake8_report.txt")
withopen(flake8_output_file,"w")as flake8_output:
flake8_command =f"flake8 {file_path}"
subprocess.run(flake8_command, shell=True, stdout=flake8_output, stderr=subprocess.STDOUT)
print(f"Flake8 report saved to {flake8_output_file}")
# Run Bandit (security analysis)
print("\nRunning Bandit...")
bandit_output_file = os.path.join(report_dir,f"{file}_bandit_report.txt")
withopen(bandit_output_file,"w")as bandit_output:
bandit_command =f"bandit -r {file_path}"
subprocess.run(bandit_command, shell=True, stdout=bandit_output, stderr=subprocess.STDOUT)
print(f"Bandit report saved to {bandit_output_file}")
print(f"Analyzing file: {file} Completed!!!!")
print('================'*5)
print('================'*5
if __name__ =="__main__":
directory =r"C:\Users\abhay\OneDrive\Desktop\auto\Part7"
analyze_code(directory)
2、剪贴板管理器 2.0 📋
这个自动化脚本就是你的剪贴板助手。它能监控你复制的所有文本，并提供无缝翻译。它利用 Pyperclip 的强大功能来捕捉复制的数据，利用 Tkinter 提供时尚、用户友好的界面，并利用 GoogleTranslate 将非母语的复制文本翻译成英语，确保您保持条理清晰，不会丢失重要信息。
import tkinter as tk
from tkinter import ttk
import pyperclip
from deep_translator importGoogleTranslator
from langdetect import detect
defdetect_and_translate(text):
try:
# Detect and Translate if Not in English
detected_language = detect(text)
print(f"Detected language: {detected_language}")
if detected_language !='en':
translated_text =GoogleTranslator(source=detected_language, target='en').translate(text)
print(f"Translated text: {translated_text}")
return translated_text
else:
print("The text is already in English.")
return text
exceptExceptionas e:
print(f"Error: {e}")
return text
## Update and Append GUI with Newly Copied Text
defupdate_listbox():
new_item = pyperclip.paste()
new_item = detect_and_translate(new_item)
if new_item notin X:
X.append(new_item)
listbox.insert(tk.END, new_item)
listbox.insert(tk.END,"----------------------")
listbox.yview(tk.END)
root.after(1000, update_listbox)
## Checks for Copied Contet
defcopy_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()
3、DNSFetcher
域名系统（DNS）是互联网的主干，它将人类可读的域名转换成机器用于通信的 IP 地址。DNS 记录是定义域配置（如邮件服务器、IP 地址和安全设置）的重要信息。
这些记录在确保无缝连接和维护在线系统完整性方面发挥着至关重要的作用。然而，DNS 记录不仅对运行非常重要，还是网络安全的重点。
监控 DNS 记录可以提供恶意活动的早期指标，因为威胁行为者通常会操纵 DNS 记录进行网络钓鱼活动、数据外渗或恶意软件分发。在跟踪可疑域名时，查看这些记录尤为重要，因为 DNS 配置的变化可能预示着潜在的威胁或域名滥用。
该自动化脚本是减少工作量的重要工具。它将域名作为输入，自动检索所有相关 DNS 记录，提供域名配置的完整概览，帮助您轻松分析和监控变化。
import dns.resolver
from termcolor import colored # For a colored console!!
defcheck_dns_records(domain):
try:
record_types =['A','AAAA','MX','CNAME','TXT','NS','SOA']
resolver = dns.resolver.Resolver()
results ={}
for record_type in record_types:
try:
answer = resolver.resolve(domain, record_type)
results[record_type]=[str(rdata)for rdata in answer]
except dns.resolver.NoAnswer:
results[record_type]=[]
except dns.resolver.NXDOMAIN:
results[record_type]=[]
except dns.resolver.NoNameservers:
results[record_type]=[]
exceptExceptionas e:
results[record_type]=str(e)
return results
exceptExceptionas e:
return{'error':str(e)}
defdisplay_results(domain, results):
print("\n"+ colored(f"DNS Records for {domain}","cyan", attrs=["bold"]))
print("="*(len(f"DNS Records for {domain}")+2))
if'error'in results:
print(colored(f"Error: {results['error']}","red"))
return
for record_type, record_data in results.items():
if record_type =="A":
record_title ="IPv4 Addresses"
elif record_type =="AAAA":
record_title ="IPv6 Addresses"
elif record_type =="MX":
record_title ="Mail Exchanger"
elif record_type =="CNAME":
record_title ="Canonical Name"
elif record_type =="TXT":
record_title ="Text Records"
elif record_type =="NS":
record_title ="Name Servers"
elif record_type =="SOA":
record_title ="Start of Authority"
print(f"\n{colored(record_title, 'yellow', attrs=['bold'])}:")
if record_data:
for record in record_data:
print(f" - {colored(record, 'green')}")
else:
print(colored(" Not found","red"))
print("\n"+"="*40)
if __name__ =="__main__":
domain =input("Enter domain to check DNS records: ").strip()
results = check_dns_records(domain)
display_results(domain, results)
4、Memoir
在我们这个快节奏的世界里，捕捉稍纵即逝的想法、提醒或思绪常常让人感觉是在与时间赛跑。语音记事本已成为人们在繁忙的日程安排、创意头脑风暴会议或个人思考中不可或缺的工具。无论是在通勤途中闪现的灵感，还是一天的待办事项，Voicenotes 都能提供一种快速、免提的方式来记录和重温重要时刻，而无需费力写下来。
然而，管理语音笔记可能很棘手。手动创建和整理常常会导致存储杂乱无章、文件丢失或遗漏见解。在时间已经很紧张的情况下，这个过程可能会让人感到沮丧。你很容易忘记安全地保存这些笔记，或以简单高效的方式组织它们，以便日后查找。
这就是我开发 Memoir 的原因，它是一个 Python 自动化脚本，可以为你无缝创建、组织和保存语音笔记，从而简化整个过程。
import tkinter as tk
from tkinter import messagebox
import pyaudio
import wave
import os
from datetime import datetime
from playsound import playsound
# Ensure directory exists for recordings
os.makedirs("assets/recordings", exist_ok=True)
# Initialize the main window
root = tk.Tk()
root.title("Memoir 🎙️")
root.geometry("550x500")
root.config(bg="#F1F5F9")# Background color
# Initialize notes list
notes =[]
defrecord_audio(duration):
fs =48000# Sample rate
channels =2# Stereo
chunk =1024# Size of each audio chunk
# Filename for saving your voicenotes
filename =f"assets/recordings/AudioNote_{datetime.now().strftime('%Y%m%d_%H%M%S')}.wav"
p = pyaudio.PyAudio()
# Open the stream for audio recording
stream = p.open(format=pyaudio.paInt16,# Audio format (16-bit)
channels=channels,
rate=fs,
input=True,
frames_per_buffer=chunk)
frames =[]
# Record audio in chunks
for _ inrange(0,int(fs / chunk * duration)):
data = stream.read(chunk)
frames.append(data)
# Stop recording
stream.stop_stream()
stream.close()
p.terminate()
# Save audio to a .wav file
with wave.open(filename,'wb')as wf:
wf.setnchannels(channels)
wf.setsampwidth(p.get_sample_size(pyaudio.paInt16))
wf.setframerate(fs)
wf.writeframes(b''.join(frames))
# Add recording to the list
notes.append(filename)
note_list.insert(tk.END, os.path.basename(filename))
defplay_audio():
selected_index = note_list.curselection()
if selected_index:
filename = notes[selected_index[0]]
# Use playsound to play the selected audio file
playsound(filename)
else:
messagebox.showwarning("No Selection","Please select a note to play.")
# Load any existing notes
for file in os.listdir("assets/recordings"):
if file.endswith(".wav"):
notes.append(f"assets/recordings/{file}")
# Set up the basic UI elements
header_frame = tk.Frame(root, bg="#4C6EF5", pady=20)
header_frame.pack(fill="x")
header_label = tk.Label(header_frame, text="Memoir🎙️", bg="#4C6EF5", fg="white", font=("Arial",20,"bold"))
header_label.pack()
tk.Label(root, text="Record for (seconds):", bg="#F1F5F9", font=("Arial",12)).pack(pady=(10,5))
button_frame = tk.Frame(root, bg="#F1F5F9")
button_frame.pack()
# Record duration buttons with improved colors
record_buttons =[("5s",5),("10s",10),("15s",15)]
for text, duration in record_buttons:
button = tk.Button(button_frame, text=text, command=lambda d=duration: record_audio(d), bg="#5CBBF6", fg="white", font=("Arial",12,"bold"), width=8, relief="flat")
button.grid(row=0, column=record_buttons.index((text, duration)), padx=15, pady=10)
tk.Label(root, text="Recorded Notes:", bg="#F1F5F9", font=("Arial",12)).pack(pady=(15,5))
note_list = tk.Listbox(root, height=8, font=("Arial",12), bg="#FFFFFF", fg="#333333", selectmode=tk.SINGLE, bd=2, relief="groove")
note_list.pack(padx=20, pady=10, fill=tk.BOTH)
# Populate the notes list box
for note in notes:
note_list.insert(tk.END, os.path.basename(note))
# Playback button with a sleek design
play_button = tk.Button(root, text="Play Selected Note", command=play_audio, bg="#FF6F61", fg="white", font=("Arial",12,"bold"), width=20, relief="flat")
play_button.pack(pady=(15,5))
# Footer with app description
footer_frame = tk.Frame(root, bg="#4C6EF5", pady=10)
footer_frame.pack(fill="x", side="bottom")
footer_label = tk.Label(footer_frame, text="A Tool for managing VoiceNotes Effortlessly!!", bg="#4C6EF5", fg="white", font=("Arial",10))
footer_label.pack()
root.mainloop()
无论您是学生、专业人士，还是喜欢随时随地记录想法的人，Memoir 都能让您轻松无压力地记录想法。
5、 FilterText
处理社交媒体内容和挖掘有意义的洞察力可能会让人感觉力不从心，尤其是当你需要处理大量文本数据时。
这就是这个自动化脚本可以帮你节省时间的地方，它利用自然语言处理（NLP）的强大功能过滤文本，并自动提取关键要素，如标签、提及和关键词，这样你就不必手动处理所有内容并编写大量代码。
它不仅能提取关键信息，还能为您清除不必要的噪音，从而净化数据
import re
import pandas as pd
import streamlit as st
import matplotlib.pyplot as plt
import seaborn as sns
from collections importCounter
# Define regex patterns for various filters
patterns ={
'emails':r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
'mentions':r'@\w+',
'hashtags':r'#\w+',
'links':r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+',
'html_tags':r'<[^>]+>',
'phone_numbers':r'\+?\d{1,3}[-.\s]?\(?\d{1,4}?\)?[-.\s]?\d{1,4}[-.\s]?\d{1,9}',
'dates':r'\b\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b|\b\d{4}[/-]\d{1,2}[/-]\d{1,2}\b',
'currency':r'\$\d+(?:\.\d{2})?|€\d+(?:\.\d{2})?|£\d+(?:\.\d{2})?|USD\s\d+(?:\.\d+)?',
'emojis':r'[\U0001F600-\U0001F64F\U0001F300-\U0001F5FF\U0001F680-\U0001F6FF\U0001F700-\U0001F77F\U0001F900-\U0001F9FF]+',
}
## Function for preprocessing
defprocess_text(text, filters, mode):
if mode =='extract':
return{filter_type: re.findall(patterns[filter_type], text)for filter_type in filters}
elif mode =='clean':
cleaned_text = text
for filter_type in filters:
cleaned_text = re.sub(patterns[filter_type],'', cleaned_text)
return{'cleaned_text': cleaned_text}
# Plot Filtered Data
defplot_data(data, title):
# Count occurrences of each item and get the top 15
item_counts =Counter(data).most_common(15)
items, counts =zip(*item_counts)
# Create a bar plot
plt.figure(figsize=(10,5))
sns.barplot(x=list(items), y=list(counts), palette='viridis')
plt.title(title)
plt.xlabel('Items')
plt.ylabel('Counts')
plt.xticks(rotation=45)
st.pyplot(plt)
## Streamlit App Designing
st.title("Text Filter and Cleaner Web App")
uploaded_file = st.file_uploader("Upload a CSV file",type='csv')
if uploaded_file isnotNone:
df = pd.read_csv(uploaded_file)
st.write("Data Preview:")
st.dataframe(df)
selected_column = st.selectbox("Select a column to process:", df.columns.tolist())
st.sidebar.header("Mode Selection")
mode = st.sidebar.selectbox("Select mode:",['extract','clean'])
st.sidebar.header("Filter Options")
selected_filters = st.sidebar.multiselect("Select filters to apply:",list(patterns.keys()))
if st.button("Process Selected Column"):
if selected_column andnot df[selected_column].isnull().all():
text_input = df[selected_column].astype(str).str.cat(sep=' ')
processed_info = process_text(text_input, selected_filters, mode)
if mode =='extract':
st.subheader("Extracted Information")
for filter_type in selected_filters:
data = processed_info.get(filter_type,[])
if data:
plot_data(data,f'Top 15 {filter_type.capitalize()} Used')
st.dataframe(pd.DataFrame.from_dict(processed_info, orient='index').transpose())
elif mode =='clean':
st.subheader("Cleaned Text")
st.write(processed_info['cleaned_text'])
else:
st.error("Please select a valid column with data.")
else:
text_input = st.text_area("Enter text to filter or clean:", height=200)
if st.button("Process Text"):
if text_input:
processed_info = process_text(text_input, selected_filters, mode)
st.subheader("Processed Information")
if mode =='extract':
for filter_type in selected_filters:
data = processed_info.get(filter_type,[])
if data:
plot_data(data,f'Top 15 {filter_type.capitalize()} Used')
st.dataframe(pd.DataFrame.from_dict(processed_info, orient='index').transpose())
elif mode =='clean':
st.write(processed_info['cleaned_text'])
else:
st.error("Please enter text to process.")
6、OrganizeIT 3.0
您的下载文件夹是否杂乱无章？ 您是否在最需要的时候找不到文件？ 您是否尝试过整理目录，但却半途而废？
这个自动化脚本能在短短几分钟内彻底改变你的文件管理方式。只需提供要整理的文件夹的路径，脚本就会根据文件最后修改的日期自动将所有文件排序到文件夹中。
等等，还有更多！该脚本可确保每个文件都放在相应的文件夹中，在保持原有顺序的同时，创建一个易于浏览的逻辑结构。
import os
import shutil
from datetime import datetime
deforganize_files_by_date(directory):
# Create a list of all files in the directory
all_files =[os.path.join(directory, f)for f in os.listdir(directory)if os.path.isfile(os.path.join(directory, f))]
# Iterate over each file
for file_path in all_files:
# Get the modification date of the file
modification_time = os.path.getmtime(file_path)
modification_date = datetime.fromtimestamp(modification_time).strftime('%Y-%m-%d')
# Create a directory for the modification date if it doesn't exist
date_directory = os.path.join(directory, modification_date)
ifnot os.path.exists(date_directory):
os.makedirs(date_directory)
# Move the file to the new directory
shutil.move(file_path, os.path.join(date_directory, os.path.basename(file_path)))
print("Files organized by date successfully!")
if __name__ =="__main__":
# Specify the directory to organize
directory_to_organize ="C:\\Users\\abhay\\OneDrive\\Desktop\\TEST"# Change this to your directory path
organize_files_by_date(directory_to_organize)
7、WorkWatch
有效管理任务需要的不仅仅是良好的意愿，还需要准确了解时间的使用情况。时间跟踪可以帮助你发现模式、优化工作流程并保持责任感。它是将您的努力转化为可衡量的进展并确保分秒必争的关键工具。
手动跟踪任务和时间很快就会变得力不从心。记住开始时间、计算持续时间和维护日志会扰乱工作流程，并增加出错的可能性。结果是什么？生产力工具变成了你清单上的另一项任务。
该自动化脚本通过简单、直观的解决方案消除了这些令人头疼的问题。它实现了跟踪流程自动化，允许您设置自定义任务持续时间、实时监控进度并自动生成详细日志，这样您就可以专注于真正重要的事情。
import tkinter as tk
from tkinter import ttk, messagebox
import csv
import time
from datetime import datetime
classTaskTrackerApp:
def__init__(self, root):
self.root = root
self.root.title("WorkWatch: An App For Tracking Your Spend Time")
self.task_name_var = tk.StringVar()
self.probable_time_var = tk.IntVar()
self.start_time =None
self.task_name =None
self.style = ttk.Style()
self.style.configure("TLabel", font=("Helvetica",12))
self.style.configure("TButton", font=("Helvetica",12,'bold'), padding=6)
ttk.Label(root, text="Task Name:", foreground="blue").grid(row=0, column=0, padx=10, pady=10)
self.task_name_entry = ttk.Entry(root, textvariable=self.task_name_var, width=30, font=("Helvetica",12))
self.task_name_entry.grid(row=0, column=1, padx=10, pady=10)
ttk.Label(root, text="Probable Time (minutes):", foreground="blue").grid(row=1, column=0, padx=10, pady=10)
self.probable_time_entry = ttk.Entry(root, textvariable=self.probable_time_var, width=30, font=("Helvetica",12))
self.probable_time_entry.grid(row=1, column=1, padx=10, pady=10)
self.start_button = ttk.Button(root, text="Start Task", command=self.start_task, style="TButton")
self.start_button.grid(row=2, column=0, padx=10, pady=10)
self.stop_button = ttk.Button(root, text="Stop Task", command=self.stop_task, state=tk.DISABLED, style="TButton")
self.stop_button.grid(row=2, column=1, padx=10, pady=10)
self.reset_button = ttk.Button(root, text="Reset", command=self.reset_task, style="TButton")
self.reset_button.grid(row=3, column=0, padx=10, pady=10)
self.view_logs_button = ttk.Button(root, text="View Time Logs", command=self.view_time_logs, style="TButton")
self.view_logs_button.grid(row=3, column=1, padx=10, pady=10)
self.timer_label = ttk.Label(root, text="00:00:00", font=("Helvetica",18,'bold'), foreground="green")
self.timer_label.grid(row=4, column=0, columnspan=2, padx=10, pady=20)
withopen("time_log.csv","a", newline="")as file:
writer = csv.writer(file)
if file.tell()==0:
writer.writerow(['Task Name','Probable Time (minutes)','Start Time','End Time','Time Spent (minutes)','Time Difference (minutes)'])
self.root.mainloop()
defstart_task(self):
self.task_name = self.task_name_var.get()
probable_time =int(self.probable_time_var.get())
if self.task_name:
self.start_button.config(state=tk.DISABLED)
self.stop_button.config(state=tk.NORMAL)
self.start_time = time.time()
self.update_timer()
defstop_task(self):
self.stop_button.config(state=tk.DISABLED)
self.start_button.config(state=tk.NORMAL)
end_time = time.time()
time_spent = end_time - self.start_time
minutes_spent =round(time_spent /60,2)
self.log_time(minutes_spent)
self.start_time =None
defupdate_timer(self):
if self.start_time:
current_time = time.time()
time_spent = current_time - self.start_time
m, s =divmod(time_spent,60)
h, m =divmod(m,60)
time_spent_str ="%02d:%02d:%02d"%(h, m, s)
self.timer_label.config(text=time_spent_str)
self.root.after(1000, self.update_timer)
deflog_time(self, time_spent=0):
end_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
time_diff =round(time_spent - self.probable_time_var.get(),2)
withopen("time_log.csv","a", newline="")as file:
writer = csv.writer(file)
writer.writerow([self.task_name, self.probable_time_var.get(), self.start_time, end_time, time_spent, time_diff])
defreset_task(self):
self.task_name_var.set("")
self.probable_time_var.set("")
self.timer_label.config(text="00:00:00")
self.start_time =None
self.start_button.config(state=tk.NORMAL)
self.stop_button.config(state=tk.DISABLED)
defview_time_logs(self):
try:
withopen("time_log.csv","r")as file:
reader = csv.reader(file)
logs =list(reader)
iflen(logs)>1:
log_window = tk.Toplevel(self.root)
log_window.title("Time Logs")
text_area = tk.Text(log_window, height=20, width=120, font=("Helvetica",12))
text_area.pack(padx=10, pady=10)
for log in logs[1:]:
task_name, probable_time, start_time, end_time, time_spent, time_diff = log
log_entry =f"Task Name: {task_name}, Probable Time: {probable_time} min, Time Spent: {time_spent} min, Time Diff: {time_diff} min\n"
iffloat(time_diff)<0:
text_area.insert(tk.END, log_entry,"green")
else:
text_area.insert(tk.END, log_entry,"red")
text_area.config(state=tk.DISABLED)
text_area.tag_config("green", foreground="green")
text_area.tag_config("red", foreground="red")
else:
messagebox.showinfo("No Logs","No task logs found.")
exceptExceptionas e:
messagebox.showerror("Error",f"Could not read time logs: {e}")
if __name__ =="__main__":
root = tk.Tk()
app =TaskTrackerApp(root)
8、WordTracker
您是否打字速度很快，但却很难跟踪自己的工作效率？您是否希望能实时查看自己的打字量和错误频率？您是否对自己在写作过程中最常用的单词感到好奇？
这个自动化脚本会在你打字时跟踪你的字数，将每按一次空格键算作一个新字，同时监控回空格以跟踪更正情况。它不仅能以最新的字数显示你的进度，还能在你达到 500 字或 1000 字等重要里程碑时通知你，是你保持动力的最佳选择。
此外，该应用程序还能提供有关你写作习惯的深入统计，包括你输入的最常用的单词和退格次数。准备好优化你的写作过程，让每个字都算数！
import tkinter as tk
from tkinter import messagebox
from pynput import keyboard
import collections
import threading
classWordCounterApp:
def__init__(self, root):
self.root = root
self.root.title("Word Counter")
self.create_widgets()
self.word_count =0
self.backspace_count =0
self.words = collections.Counter()
self.current_input =""
self.reached_milestones =set()
self.listener_thread = threading.Thread(target=self.start_key_listener)
self.listener_thread.start()
defcreate_widgets(self):
self.word_count_label = tk.Label(self.root, text="Word Counter: 0", font=("Helvetica",16,"bold"), bg="#f0f0f0", fg="#333")
self.word_count_label.pack(pady=20)
self.quit_button = tk.Button(self.root, text="Quit", command=self.quit_application, font=("Helvetica",12,"bold"), bg="#ff6347", fg="white", relief="flat")
self.quit_button.pack(pady=20)
defstart_key_listener(self):
with keyboard.Listener(on_press=self.on_keyboard_event)as listener:
listener.join()
defon_keyboard_event(self, key):
try:
if key == keyboard.Key.space:
if self.current_input.strip():
self.word_count +=1
self.words[self.current_input.strip().lower()]+=1
self.current_input =""
self.update_word_count_label()
elif key == keyboard.Key.backspace:
self.backspace_count +=1
if self.current_input:
self.current_input = self.current_input[:-1]
else:
char =getattr(key,'char',None)
if char and char.isalnum():
self.current_input += char
self.check_word_milestones()
exceptAttributeError:
pass
defupdate_word_count_label(self):
self.word_count_label.config(text=f"Word Counter: {self.word_count}")
defcheck_word_milestones(self):
# Define milestones
milestones =[500,1000,1500,2000]
for milestone in milestones:
if self.word_count == milestone and milestone notin self.reached_milestones:
self.show_notification(milestone)
self.reached_milestones.add(milestone)
defshow_notification(self, milestone):
messagebox.showinfo("Milestone Reached",f"Congratulations! You've written {milestone} words!")
defquit_application(self):
# Stop listener gracefully and show stats window
self.show_stats_window()
defshow_stats_window(self):
# Create a new Tkinter window to show the stats
stats_window = tk.Toplevel(self.root)
stats_window.title("Session Stats")
stats_window.config(bg="#f0f0f0")
# Set window size
stats_window.geometry("350x300")
# Display backspace count
backspace_label = tk.Label(stats_window, text=f"Backspace pressed: {self.backspace_count}", font=("Helvetica",14), bg="#f0f0f0", fg="#555")
backspace_label.pack(pady=10)
# Display top 10 most dominant words
dominant_words_label = tk.Label(stats_window, text="Most Dominant Words (Top 10):", font=("Helvetica",14,"bold"), bg="#f0f0f0", fg="#555")
dominant_words_label.pack(pady=10)
top_words = self.words.most_common(10)
for word, count in top_words:
word_label = tk.Label(stats_window, text=f"{word}: {count}", font=("Helvetica",12), bg="#f0f0f0", fg="#333")
word_label.pack(pady=3)
# Add scrollbar to stats window
canvas = tk.Canvas(stats_window, bg="#f0f0f0")
scrollbar = tk.Scrollbar(stats_window, orient="vertical", command=canvas.yview)
canvas.configure(yscrollcommand=scrollbar.set)
scrollbar.pack(side="right", fill="y")
canvas.pack(side="left", fill="both", expand=True)
# Add a frame to contain the labels inside the canvas
frame = tk.Frame(canvas, bg="#f0f0f0")
canvas.create_window((0,0), window=frame, anchor="nw")
# Update scroll region
frame.update_idletasks()
canvas.config(scrollregion=canvas.bbox("all"))
if __name__ =="__main__":
root = tk.Tk()
app =WordCounterApp(root)
root.mainloop()
9、PomodoroPro
您听说过 Pomodoro Technique 吗？Pomodoro Technique 是 Francesco Cirillo 在 20 世纪 80 年代末开发的一种提高工作效率的方法。它的基本思想是将工作分成若干个时间段，传统长度为 25 分钟，中间有短暂的休息。这些时间间隔被称为 "pomodoros"（意大利语，意为 "番茄"，因西里洛使用的番茄形计时器而得名）。
我个人曾使用过一段时间这种方法，即在进行长时间的项目时，设置一个 25 分钟的闹钟或计时器。然而，我经常发现自己跳过了休息时间，因为没有任何东西能迫使我从工作中抽身出来。因此，我决定创建一个解决方案来解决这个问题：一个自动化脚本，它不仅能跟踪 Pomodoro 计时器，还能在计时器耗尽时锁定我的设备，确保我不得不休息一下。
这个 Python 自动化脚本是一个简单而有效的图形用户界面，可以运行一个 Pomodoro（通常为 25 分钟），一旦计时器归零，它就会自动锁定我的设备，迫使我休息一下！
我使用它已经有一个月了，我可以自信地说，它大大提高了我的工作效率，也改善了我的坐姿习惯。
import tkinter as tk
import time
import ctypes
import os
from threading importTimer
classPomodoroTimer:
def__init__(self, root):
self.root = root
self.root.title("Pomodoro Timer")
self.root.geometry("300x200")
self.time_var = tk.StringVar()
self.time_var.set("25:00")
self.running =False
self.paused =False
self.remaining_time =25*60# 25 minutes
self.label = tk.Label(root, textvariable=self.time_var, font=("Helvetica",48))
self.label.pack(pady=20)
self.start_button = tk.Button(root, text="Start", command=self.start_timer)
self.start_button.pack(side=tk.LEFT, padx=10)
self.pause_button = tk.Button(root, text="Pause", command=self.pause_timer)
self.pause_button.pack(side=tk.LEFT, padx=10)
self.reset_button = tk.Button(root, text="Reset", command=self.reset_timer)
self.reset_button.pack(side=tk.LEFT, padx=10)
defupdate_time(self):
if self.running:
minutes, seconds =divmod(self.remaining_time,60)
self.time_var.set(f"{minutes:02}:{seconds:02}")
if self.remaining_time >0:
self.remaining_time -=1
self.root.after(1000, self.update_time)
else:
self.running =False
self.lock_screen()
defstart_timer(self):
ifnot self.running:
self.running =True
self.paused =False
self.update_time()
defpause_timer(self):
if self.running:
self.running =False
self.paused =True
defreset_timer(self):
self.running =False
self.paused =False
self.remaining_time =25*60
self.time_var.set("25:00")
deflock_screen(self):
if os.name =='nt':# Windows
ctypes.windll.user32.LockWorkStation()
elif os.name =='posix':# macOS and Linux
# This is a placeholder, as locking the screen in macOS/Linux typically requires different handling
# For macOS, use: os.system('/System/Library/CoreServices/Menu\ Extras/User.menu/Contents/Resources/CGSession -suspend')
# For Linux, use: os.system('gnome-screensaver-command --lock')
print("Locking screen on macOS/Linux is not implemented in this script.")
if __name__ =="__main__":
root = tk.Tk()
app =PomodoroTimer(root)
root.mainloop()
最新热门文章推荐：
国外C++程序员分享：2024/2025年C++是否还值得学习？
国外Python程序员分享：如何用Python构建一个多代理AI应用
国外CUDA程序员分享：2024年GPU编程CUDA C++（从环境安装到进阶技巧）
国外Python程序员分享：2024年NumPy高性能计算库（高级技巧）
外国人眼中的卢湖川：从大连理工到全球舞台，他的科研成果震撼世界！
外国人眼中的张祥雨：交大90后男神博士，3年看1800篇论文，还入选福布斯精英榜
参考文献：《图片来源网络》 《10 Insanely Useful Automation Scripts You Need to Try Using Python》
本文使用 文章同步助手 同步
