都知道现实中有很多重复而且单一的工作比如把同一个东西拧上螺丝，很显然在我们学习了一些编程，可以用代码解决这些问题。
我解决的就是微软的rewards它要求你要搜索不同的网站来获得积分，可是手工一次又一次刷太麻烦，使用我用ai写了一个可以代替你去搜索的脚本
import tkinter as tk
from tkinter import ttk, scrolledtext, messagebox
import threading
import time
import random
import logging
import platform
import os
import sys
import tempfile
import shutil
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
class BrowserSearchBotGUI:
def __init__(self, root):
self.root = root
self.root.title("默认浏览器搜索助手")
self.root.geometry("800x700")
self.root.resizable(True, True)
# 先设置日志
self.setup_logging()
# 设置图标（如果有的话）
try:
if getattr(sys, 'frozen', False):
base_path = os.path.dirname(sys.executable)
else:
base_path = os.path.dirname(os.path.abspath(__file__))
icon_path = os.path.join(base_path, 'icon.ico')
if os.path.exists(icon_path):
self.root.iconbitmap(icon_path)
except:
pass
self.bot = None
self.is_running = False
self.setup_ui()
def setup_logging(self):
"""设置日志"""
if getattr(sys, 'frozen', False):
base_path = os.path.dirname(sys.executable)
else:
base_path = os.path.dirname(os.path.abspath(__file__))
log_file = os.path.join(base_path, 'browser_search.log')
# 创建logger
self.logger = logging.getLogger('BrowserSearchBot')
self.logger.setLevel(logging.INFO)
# 避免重复添加handler
if not self.logger.handlers:
# 文件handler
file_handler = logging.FileHandler(log_file, encoding='utf-8')
file_handler.setLevel(logging.INFO)
# 控制台handler
stream_handler = logging.StreamHandler(self)
stream_handler.setLevel(logging.INFO)
# 格式
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
stream_handler.setFormatter(formatter)
self.logger.addHandler(file_handler)
self.logger.addHandler(stream_handler)
def write(self, message):
"""重写write方法用于日志显示"""
if message.strip():
self.log_display.insert(tk.END, message)
self.log_display.see(tk.END)
self.root.update()
def flush(self):
"""重写flush方法"""
pass
def setup_ui(self):
"""设置用户界面"""
# 创建主框架
main_frame = ttk.Frame(self.root, padding="10")
main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
# 配置网格权重
self.root.columnconfigure(0, weight=1)
self.root.rowconfigure(0, weight=1)
main_frame.columnconfigure(1, weight=1)
# 标题
title_label = ttk.Label(main_frame, text="默认浏览器搜索助手",
font=("Arial", 16, "bold"))
title_label.grid(row=0, column=0, columnspan=2, pady=(0, 20))
# 网站设置框架
website_frame = ttk.LabelFrame(main_frame, text="网站设置", padding="10")
website_frame.grid(row=1, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(0, 10))
website_frame.columnconfigure(1, weight=1)
ttk.Label(website_frame, text="目标网站:").grid(row=0, column=0, sticky=tk.W, padx=(0, 10))
self.website_var = tk.StringVar(value="https://rewards.bing.com/")
website_entry = ttk.Entry(website_frame, textvariable=self.website_var, width=50)
website_entry.grid(row=0, column=1, sticky=(tk.W, tk.E))
# 浏览器设置框架
browser_frame = ttk.LabelFrame(main_frame, text="浏览器设置", padding="10")
browser_frame.grid(row=2, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(0, 10))
self.browser_mode_var = tk.StringVar(value="temp")
ttk.Radiobutton(browser_frame, text="使用临时浏览器配置（推荐）",
variable=self.browser_mode_var, value="temp").grid(row=0, column=0, sticky=tk.W, columnspan=2)
ttk.Radiobutton(browser_frame, text="使用持久化浏览器配置",
variable=self.browser_mode_var, value="persistent").grid(row=1, column=0, sticky=tk.W)
ttk.Radiobutton(browser_frame, text="使用默认浏览器配置",
variable=self.browser_mode_var, value="default").grid(row=1, column=1, sticky=tk.W)
# 配置说明
info_text = """临时配置：每次重新启动，无需登录但会打开新窗口
持久化配置：保存登录状态，但可能因配置文件冲突导致卡住
默认配置：使用系统Chrome配置，可能需要管理员权限"""
info_label = ttk.Label(browser_frame, text=info_text,
font=("Arial", 8), foreground="gray", justify=tk.LEFT)
info_label.grid(row=2, column=0, columnspan=2, sticky=tk.W, pady=(5, 0))
# 手动登录按钮
login_button = ttk.Button(browser_frame, text="手动登录模式",
command=self.manual_login_mode)
login_button.grid(row=3, column=0, columnspan=2, pady=(10, 0))
# 搜索设置框架
search_frame = ttk.LabelFrame(main_frame, text="搜索设置", padding="10")
search_frame.grid(row=3, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(0, 10))
# 第一行
ttk.Label(search_frame, text="最小间隔(秒):").grid(row=0, column=0, sticky=tk.W, padx=(0, 10))
self.min_interval_var = tk.StringVar(value="5")
ttk.Entry(search_frame, textvariable=self.min_interval_var, width=10).grid(row=0, column=1, sticky=tk.W, padx=(0, 20))
ttk.Label(search_frame, text="最大间隔(秒):").grid(row=0, column=2, sticky=tk.W, padx=(0, 10))
self.max_interval_var = tk.StringVar(value="8")
ttk.Entry(search_frame, textvariable=self.max_interval_var, width=10).grid(row=0, column=3, sticky=tk.W, padx=(0, 20))
# 第二行
ttk.Label(search_frame, text="输入速度(秒/字符):").grid(row=1, column=0, sticky=tk.W, padx=(0, 10))
self.typing_speed_var = tk.StringVar(value="0.1")
ttk.Entry(search_frame, textvariable=self.typing_speed_var, width=10).grid(row=1, column=1, sticky=tk.W, padx=(0, 20))
ttk.Label(search_frame, text="每次关键词数:").grid(row=1, column=2, sticky=tk.W, padx=(0, 10))
self.keywords_num_var = tk.StringVar(value="2")
ttk.Entry(search_frame, textvariable=self.keywords_num_var, width=10).grid(row=1, column=3, sticky=tk.W)
# 关键词管理框架
keywords_frame = ttk.LabelFrame(main_frame, text="关键词管理", padding="10")
keywords_frame.grid(row=4, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(0, 10))
keywords_frame.columnconfigure(0, weight=1)
# 关键词输入区域
keywords_input_frame = ttk.Frame(keywords_frame)
keywords_input_frame.grid(row=0, column=0, sticky=(tk.W, tk.E), pady=(0, 10))
keywords_input_frame.columnconfigure(0, weight=1)
ttk.Label(keywords_input_frame, text="添加关键词:").grid(row=0, column=0, sticky=tk.W)
self.new_keyword_var = tk.StringVar()
keyword_entry = ttk.Entry(keywords_input_frame, textvariable=self.new_keyword_var)
keyword_entry.grid(row=1, column=0, sticky=(tk.W, tk.E), pady=(5, 0))
keyword_entry.bind('<Return>', lambda e: self.add_keyword())
ttk.Button(keywords_input_frame, text="添加",
command=self.add_keyword).grid(row=1, column=1, padx=(10, 0))
# 关键词列表
keywords_list_frame = ttk.Frame(keywords_frame)
keywords_list_frame.grid(row=1, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
keywords_list_frame.columnconfigure(0, weight=1)
keywords_list_frame.rowconfigure(0, weight=1)
self.keywords_listbox = tk.Listbox(keywords_list_frame, height=6)
self.keywords_listbox.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), padx=(0, 10))
# 关键词列表按钮框架
list_buttons_frame = ttk.Frame(keywords_list_frame)
list_buttons_frame.grid(row=0, column=1, sticky=(tk.N, tk.S))
ttk.Button(list_buttons_frame, text="删除选中",
command=self.delete_keyword).pack(fill=tk.X, pady=(0, 5))
ttk.Button(list_buttons_frame, text="清空列表",
command=self.clear_keywords).pack(fill=tk.X, pady=5)
ttk.Button(list_buttons_frame, text="加载默认",
command=self.load_default_keywords).pack(fill=tk.X, pady=5)
# 控制按钮框架
control_frame = ttk.Frame(main_frame)
control_frame.grid(row=5, column=0, columnspan=2, pady=(10, 10))
self.start_button = ttk.Button(control_frame, text="开始搜索",
command=self.start_search)
self.start_button.pack(side=tk.LEFT, padx=(0, 10))
self.stop_button = ttk.Button(control_frame, text="停止搜索",
command=self.stop_search, state=tk.DISABLED)
self.stop_button.pack(side=tk.LEFT, padx=(0, 10))
ttk.Button(control_frame, text="清空日志",
command=self.clear_log).pack(side=tk.LEFT)
ttk.Button(control_frame, text="清除配置文件",
command=self.clear_profile).pack(side=tk.LEFT, padx=(10, 0))
# 日志显示框架
log_frame = ttk.LabelFrame(main_frame, text="运行日志", padding="10")
log_frame.grid(row=6, column=0, columnspan=2, sticky=(tk.W, tk.E, tk.N, tk.S), pady=(0, 10))
log_frame.columnconfigure(0, weight=1)
log_frame.rowconfigure(0, weight=1)
main_frame.rowconfigure(6, weight=1)
self.log_display = scrolledtext.ScrolledText(log_frame, height=15, width=80)
self.log_display.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
# 状态栏
status_frame = ttk.Frame(main_frame)
status_frame.grid(row=7, column=0, columnspan=2, sticky=(tk.W, tk.E))
self.status_var = tk.StringVar(value="就绪")
status_label = ttk.Label(status_frame, textvariable=self.status_var)
status_label.pack(side=tk.LEFT)
self.search_count_var = tk.StringVar(value="搜索次数: 0")
count_label = ttk.Label(status_frame, textvariable=self.search_count_var)
count_label.pack(side=tk.RIGHT)
# 加载默认关键词
self.load_default_keywords()
def manual_login_mode(self):
"""手动登录模式"""
messagebox.showinfo("手动登录模式",
"将打开浏览器，请手动登录您的账户。\n\n"
"登录完成后关闭浏览器，然后使用'临时浏览器配置'模式。")
try:
# 创建临时浏览器用于手动登录
options = Options()
options.add_argument('--start-maximized')
options.add_argument('--disable-blink-features=AutomationControlled')
driver = webdriver.Chrome(options=options)
driver.get(self.website_var.get())
self.logger.info("手动登录模式：浏览器已打开，请登录后关闭浏览器")
except Exception as e:
messagebox.showerror("错误", f"无法打开浏览器: {e}")
def clear_profile(self):
"""清除持久化配置文件"""
try:
if getattr(sys, 'frozen', False):
base_path = os.path.dirname(sys.executable)
else:
base_path = os.path.dirname(os.path.abspath(__file__))
profile_path = os.path.join(base_path, 'chrome_profile')
if os.path.exists(profile_path):
shutil.rmtree(profile_path)
self.logger.info("已清除持久化配置文件")
messagebox.showinfo("成功", "已清除持久化配置文件")
else:
messagebox.showinfo("信息", "没有找到持久化配置文件")
except Exception as e:
messagebox.showerror("错误", f"清除配置文件失败: {e}")
def add_keyword(self):
"""添加关键词"""
keyword = self.new_keyword_var.get().strip()
if keyword and keyword not in self.keywords_listbox.get(0, tk.END):
self.keywords_listbox.insert(tk.END, keyword)
self.new_keyword_var.set("")
self.logger.info(f"添加关键词: {keyword}")
def delete_keyword(self):
"""删除选中关键词"""
selection = self.keywords_listbox.curselection()
if selection:
keyword = self.keywords_listbox.get(selection[0])
self.keywords_listbox.delete(selection[0])
self.logger.info(f"删除关键词: {keyword}")
def clear_keywords(self):
"""清空关键词列表"""
self.keywords_listbox.delete(0, tk.END)
self.logger.info("清空关键词列表")
def load_default_keywords(self):
"""加载默认关键词"""
default_keywords = [
"人工智能", "机器学习", "深度学习", "数据科学", "Python编程",
"网页开发", "前端框架", "后端技术", "云计算", "大数据",
"物联网", "区块链", "网络安全", "用户体验", "响应式设计",
"自动化测试", "DevOps", "微服务", "容器化", "Kubernetes",
"Docker", "React", "Vue", "Angular", "Node.js",
"Spring Boot", "Django", "Flask", "Redis", "MongoDB"
]
self.clear_keywords()
for keyword in default_keywords:
self.keywords_listbox.insert(tk.END, keyword)
self.logger.info("加载默认关键词")
def clear_log(self):
"""清空日志"""
self.log_display.delete(1.0, tk.END)
def start_search(self):
"""开始搜索"""
if self.is_running:
return
# 验证输入
try:
min_interval = float(self.min_interval_var.get())
max_interval = float(self.max_interval_var.get())
typing_speed = float(self.typing_speed_var.get())
keywords_num = int(self.keywords_num_var.get())
if min_interval <= 0 or max_interval <= 0 or typing_speed <= 0 or keywords_num <= 0:
raise ValueError("数值必须大于0")
if min_interval > max_interval:
raise ValueError("最小间隔不能大于最大间隔")
except ValueError as e:
messagebox.showerror("输入错误", f"请检查输入数值: {e}")
return
# 检查关键词
keywords = list(self.keywords_listbox.get(0, tk.END))
if len(keywords) == 0:
messagebox.showerror("错误", "请至少添加一个关键词")
return
if keywords_num > len(keywords):
messagebox.showwarning("警告", "每次关键词数大于关键词总数，将使用所有关键词")
keywords_num = len(keywords)
# 更新界面状态
self.start_button.config(state=tk.DISABLED)
self.stop_button.config(state=tk.NORMAL)
self.is_running = True
# 创建机器人实例
self.bot = BrowserSearchBot(
website_url=self.website_var.get(),
keywords=keywords,
min_interval=min_interval,
max_interval=max_interval,
typing_speed=typing_speed,
keywords_num=keywords_num,
browser_mode=self.browser_mode_var.get(),
gui_callback=self.update_gui
)
# 在新线程中运行搜索
self.search_thread = threading.Thread(target=self.run_search, daemon=True)
self.search_thread.start()
self.logger.info("开始自动搜索...")
def stop_search(self):
"""停止搜索"""
if self.is_running and self.bot:
self.is_running = False
self.bot.stop()
self.start_button.config(state=tk.NORMAL)
self.stop_button.config(state=tk.DISABLED)
self.status_var.set("已停止")
self.logger.info("停止搜索")
def run_search(self):
"""运行搜索线程"""
try:
self.bot.start_infinite_search()
except Exception as e:
self.logger.error(f"搜索出错: {e}")
finally:
self.is_running = False
self.root.after(0, self.on_search_finished)
def on_search_finished(self):
"""搜索完成后的回调"""
self.start_button.config(state=tk.NORMAL)
self.stop_button.config(state=tk.DISABLED)
self.status_var.set("搜索完成")
def update_gui(self, search_count, status):
"""更新GUI状态"""
self.root.after(0, lambda: self._update_gui_callback(search_count, status))
def _update_gui_callback(self, search_count, status):
"""在主线程中更新GUI"""
self.search_count_var.set(f"搜索次数: {search_count}")
self.status_var.set(status)
class BrowserSearchBot:
def __init__(self, website_url, keywords, min_interval=3, max_interval=5,
typing_speed=0.05, keywords_num=2, browser_mode="temp", gui_callback=None):
self.website_url = website_url
self.keywords = keywords
self.min_interval = min_interval
self.max_interval = max_interval
self.typing_speed = typing_speed
self.keywords_num = keywords_num
self.browser_mode = browser_mode
self.gui_callback = gui_callback
self.driver = None
self.is_running = False
self.search_count = 0
self.search_box = None
self.setup_logging()
def setup_logging(self):
"""设置日志"""
self.logger = logging.getLogger('BrowserSearchBot')
def get_persistent_profile_path(self):
"""获取持久化配置文件路径"""
if getattr(sys, 'frozen', False):
base_path = os.path.dirname(sys.executable)
else:
base_path = os.path.dirname(os.path.abspath(__file__))
profile_path = os.path.join(base_path, 'chrome_profile')
return profile_path
def setup_browser(self):
"""设置浏览器"""
try:
options = Options()
# 通用配置
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_experimental_option("excludeSwitches", ["enable-automation"])
options.add_experimental_option('useAutomationExtension', False)
options.add_argument('--no-first-run')
options.add_argument('--no-default-browser-check')
options.add_argument('--disable-gpu')
options.add_argument('--disable-dev-shm-usage')
options.add_argument('--no-sandbox')
if self.browser_mode == "persistent":
# 使用持久化配置
profile_path = self.get_persistent_profile_path()
options.add_argument(f"--user-data-dir={profile_path}")
options.add_argument("--profile-directory=Default")
self.logger.info(f"使用持久化浏览器配置: {profile_path}")
# 添加超时设置
options.add_argument('--disable-features=VizDisplayCompositor')
options.add_argument('--disable-background-timer-throttling')
options.add_argument('--disable-renderer-backgrounding')
elif self.browser_mode == "default":
# 使用默认浏览器配置
user_data_dir = self.get_default_user_data_dir()
if user_data_dir and os.path.exists(os.path.dirname(user_data_dir)):
options.add_argument(f"--user-data-dir={user_data_dir}")
options.add_argument("--profile-directory=Default")
self.logger.info("使用默认浏览器配置")
else:
self.logger.warning("默认浏览器配置不可用，使用临时配置")
self.browser_mode = "temp"
if self.browser_mode == "temp":
# 使用临时目录
temp_dir = tempfile.mkdtemp(prefix="chrome_temp_")
options.add_argument(f"--user-data-dir={temp_dir}")
self.logger.info(f"使用临时浏览器配置: {temp_dir}")
# 不最大化窗口，避免可能的卡住问题
options.add_argument('--window-size=1200,800')
# 设置超时
service = Service()
service.creationflags = 0x08000000 # 避免创建控制台窗口
try:
self.driver = webdriver.Chrome(service=service, options=options)
except Exception as e:
self.logger.warning(f"标准启动方式失败: {e}，尝试备用方式")
# 备用方式：不使用Service
self.driver = webdriver.Chrome(options=options)
# 设置页面加载超时
self.driver.set_page_load_timeout(30)
self.driver.implicitly_wait(10)
# 移除自动化特征
self.driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")
self.logger.info(" 成功启动浏览器")
return True
except Exception as e:
self.logger.error(f" 启动浏览器失败: {e}")
# 如果是持久化配置失败，建议使用临时配置
if self.browser_mode == "persistent":
self.logger.info("持久化配置失败，建议使用临时配置")
return False
def get_default_user_data_dir(self):
"""获取默认浏览器用户数据目录"""
try:
system = platform.system()
username = platform.node()
if system == "Windows":
path = f"C:\\Users\\{username}\\AppData\\Local\\Google\\Chrome\\User Data"
# 检查路径是否存在
if os.path.exists(os.path.dirname(path)):
return path
elif system == "Darwin":
path = f"/Users/{username}/Library/Application Support/Google/Chrome"
if os.path.exists(path):
return path
elif system == "Linux":
path = f"/home/{username}/.config/google-chrome"
if os.path.exists(path):
return path
except:
pass
return None
def find_search_box(self):
"""查找搜索框"""
if self.search_box:
return self.search_box
search_selectors = [
'input[type="search"]', 'input[name="q"]', 'input[name="search"]',
'.search-input', '#search', '#q', 'input[placeholder*="搜索"]',
'input[placeholder*="search"]', '.search-field', 'textarea[name="q"]',
'input[type="text"]', 'input[autocomplete*="search"]'
]
for selector in search_selectors:
try:
element = WebDriverWait(self.driver, 15).until(
EC.element_to_be_clickable((By.CSS_SELECTOR, selector))
)
self.logger.info(f" 找到搜索框: {selector}")
self.search_box = element
return element
except:
continue
self.logger.error("❌ 无法找到搜索框")
return None
def clear_search_box(self, search_box=None):
"""清空搜索框"""
try:
if search_box is None:
search_box = self.find_search_box()
if not search_box:
return False
search_box.send_keys(Keys.CONTROL + "a")
time.sleep(0.1)
search_box.send_keys(Keys.DELETE)
time.sleep(0.1)
return True
except Exception as e:
self.logger.error(f"清空搜索框失败: {e}")
return False
def perform_search(self, keyword):
"""执行搜索"""
try:
search_box = self.find_search_box()
if not search_box:
return False
self.clear_search_box(search_box)
# 模拟输入
for char in keyword:
search_box.send_keys(char)
time.sleep(self.typing_speed)
# 执行搜索
search_box.send_keys(Keys.RETURN)
time.sleep(2)
# 处理新窗口
main_window = self.driver.current_window_handle
all_windows = self.driver.window_handles
if len(all_windows) > 1:
for window in all_windows:
if window != main_window:
self.driver.switch_to.window(window)
time.sleep(1)
self.driver.close()
self.driver.switch_to.window(main_window)
break
self.search_count += 1
if self.gui_callback:
self.gui_callback(self.search_count, f"搜索: {keyword}")
self.logger.info(f"第 {self.search_count} 次搜索完成: {keyword}")
return True
except Exception as e:
self.logger.error(f"搜索失败: {e}")
return False
def generate_keyword(self):
"""生成随机关键词"""
num = min(self.keywords_num, len(self.keywords))
selected = random.sample(self.keywords, num)
return ' '.join(selected)
def start_infinite_search(self):
"""开始无限搜索"""
if not self.setup_browser():
self.logger.error("无法启动浏览器")
return
try:
self.driver.get(self.website_url)
time.sleep(3)
# 测试搜索框
if not self.find_search_box():
self.logger.error("无法找到搜索框，请检查网站")
return
self.is_running = True
self.logger.info(" 开始自动搜索循环")
while self.is_running:
keyword = self.generate_keyword()
success = self.perform_search(keyword)
if self.is_running and success:
interval = random.uniform(self.min_interval, self.max_interval)
self.logger.info(f"等待 {interval:.1f} 秒...")
elapsed = 0
while elapsed < interval and self.is_running:
time.sleep(1)
elapsed += 1
if self.gui_callback:
self.gui_callback(self.search_count, f"等待中... {int(interval - elapsed)}秒")
elif not success:
self.logger.warning("搜索失败，等待后重试...")
time.sleep(5)
except Exception as e:
self.logger.error(f" 发生错误: {e}")
finally:
self.stop()
def stop(self):
"""停止搜索"""
self.is_running = False
if self.driver:
try:
self.driver.quit()
except:
pass
self.logger.info(f" 搜索结束，总共执行 {self.search_count} 次搜索")
def main():
root = tk.Tk()
app = BrowserSearchBotGUI(root)
root.mainloop()
if __name__ == "__main__":
main()
