10个有趣的 Python 高级脚本,建议收藏!

来自公众号:法纳斯特

大家好,我是小F。

 

在日常的工作中,我们总会面临到各式各样的问题。

 

其中不少的问题,使用一些简单的Python代码就能解决。

 

比如不久前的复旦大佬,用130行Python代码硬核搞定核酸统计,大大提升了效率,节省了不少时间。

 

今天,小F就带大家学习一下10个Python脚本程序。

 

虽然简单,不过还是蛮有用的。

 

有兴趣的可以自己去实现,找到对自己有帮助的技巧。

 

 

▍1、Jpg转Png

 

图片格式转换,以前小F可能第一时间想到的是【格式工厂】这个软件。

 

如今编写一个Python脚本就能完成各种图片格式的转换,此处以jpg转成png为例。

 

有两种解决方法,都分享给大家。

 

# 图片格式转换, Jpg转Png

# 方法①
from PIL import Image

img = Image.open(‘test.jpg’)
img.save(‘test1.png’)


# 方法②
from cv2 import imread, imwrite

image = imread(“test.jpg”1)
imwrite(“test2.png”, image)

 

 

▍2、PDF加密和解密

 

如果你有100个或更多的PDF文件需要加密,手动进行加密肯定是不可行的,极其浪费时间。

 

使用Python的pikepdf模块,即可对文件进行加密,写一个循环就能进行批量加密文档。

 

# PDF加密
import pikepdf

pdf = pikepdf.open(“test.pdf”)
pdf.save(‘encrypt.pdf’, encryption=pikepdf.Encryption(owner=“your_password”, user=“your_password”, R=4))
pdf.close()

 

有加密那么便会有解密,代码如下。

# PDF解密
import pikepdf

pdf = pikepdf.open(“encrypt.pdf”,  password=‘your_password’)
pdf.save(“decrypt.pdf”)
pdf.close()

 

 

▍3、获取电脑的配置信息

 

很多小伙伴可能会使用鲁大师来看自己的电脑配置,这样还需要下载一个软件。

 

使用Python的WMI模块,便可以轻松查看你的电脑信息。

 

# 获取计算机信息
import wmi


def System_spec():
    Pc = wmi.WMI()
    os_info = Pc.Win32_OperatingSystem()[0]
    processor = Pc.Win32_Processor()[0]
    Gpu = Pc.Win32_VideoController()[0]
    os_name = os_info.Name.encode(‘utf-8’).split(b’|’)[0]
    ram = float(os_info.TotalVisibleMemorySize) / 1048576

    print(f’操作系统: {os_name})
    print(f’CPU: {processor.Name})
    print(f’内存: {ram} GB’)
    print(f’显卡: {Gpu.Name})

    print(“n计算机信息如上 ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑”)


System_spec()

 

就以小F自己的电脑为例,运行代码就能看到配置。

 

10个有趣的 Python 高级脚本,建议收藏!

 

 

▍4、解压文件

 

使用zipfile模块进行文件解压,同理也可以对文件进行压缩。

 

# 解压文件
from zipfile import ZipFile

unzip = ZipFile(“file.zip”“r”)
unzip.extractall(“output Folder”)

 

 

▍5、Excel工作表合并

 

帮助你将Excel工作表合并到一张表上,表内容如下图。

 

10个有趣的 Python 高级脚本,建议收藏!

 

6张表,其余表的内容和第一张表都一样。

 

设置表格数量为5,将会合并前5张表的内容。

 

import pandas as pd

# 文件名
filename = “test.xlsx”
# 表格数量
T_sheets = 5

df = []
for i in range(1, T_sheets+1):
    sheet_data = pd.read_excel(filename, sheet_name=i, header=None)
    df.append(sheet_data)

# 合并表格
output = “merged.xlsx”
df = pd.concat(df)
df.to_excel(output)

 

结果如下。

 

10个有趣的 Python 高级脚本,建议收藏!

 

 

▍6、将图像转换为素描图

 

和之前的图片格式转换有点类似,就是对图像进行处理。

 

以前大家可能会使用到美图秀秀,现在可能就是抖音的滤镜了。

 

其实使用Python的OpenCV,就能够快速实现很多你想要的效果。

 

# 图像转换
import cv2

# 读取图片
img = cv2.imread(“img.jpg”)
# 灰度
grey = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
invert = cv2.bitwise_not(grey)
# 高斯滤波
blur_img = cv2.GaussianBlur(invert, (77), 0)
inverse_blur = cv2.bitwise_not(blur_img)
sketch_img = cv2.divide(grey, inverse_blur, scale=256.0)
# 保存
cv2.imwrite(‘sketch.jpg’, sketch_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

 

原图如下。

 

10个有趣的 Python 高级脚本,建议收藏!

 

素描图如下,还挺好看的。

 

10个有趣的 Python 高级脚本,建议收藏!

 

 

▍7、获取CPU温度

 

有了这个Python脚本,你将不需要任何软件来了解CPU的温度。

 

# 获取CPU温度
from time import sleep
from pyspectator.processor import Cpu
cpu = Cpu(monitoring_latency=1)
with cpu:
    while True:
        print(f’Temp: {cpu.temperature} °C’)
        sleep(2)

 

 

▍8、提取PDF表格

 

有的时候,我们需要从PDF中提取表格数据。

 

第一时间你可能会先想到手工整理,但是当工作量特别大,手工可能就比较费劲。

 

然后你可能会想到一些软件和网络工具来提取 PDF 表格。

 

下面这个简单的脚本将帮助你在一秒钟内完成相同的操作。

 

# 方法①
import camelot

tables = camelot.read_pdf(“tables.pdf”)
print(tables)
tables.export(“extracted.csv”, f=“csv”, compress=True)

# 方法②, 需要安装Java8
import tabula

tabula.read_pdf(“tables.pdf”, pages=“all”)
tabula.convert_into(“table.pdf”“output.csv”, output_format=“csv”, pages=“all”)

 

PDF文档的内容如下,包含了一个表格。

 

10个有趣的 Python 高级脚本,建议收藏!

 

提取到的CSV文件内容如下。

 

10个有趣的 Python 高级脚本,建议收藏!

 

 

▍9、截图

 

该脚本将简单地截取屏幕截图,而无需使用任何屏幕截图软件。

 

在下面的代码中,给大家展示了两种Python截取屏幕截图的方法。

 

# 方法①
from mss import mss
with mss() as screenshot:
    screenshot.shot(output=‘scr.png’)

# 方法②
import PIL.ImageGrab
scr = PIL.ImageGrab.grab()
scr.save(“scr.png”)

 

 

▍10、拼写检查器

 

这个Python脚本可以进行拼写检查,当然只对英文有效,毕竟中文博大精深呐。

 

# 拼写检查
# 方法①
import textblob

text = “mussage”
print(“original text: “ + str(text))

checked = textblob.TextBlob(text)
print(“corrected text: “ + str(checked.correct()))

# 方法②
import autocorrect
spell = autocorrect.Speller(lang=‘en’)

# 以英语为例
print(spell(‘cmputr’))
print(spell(‘watr’))
print(spell(‘survice’))

— EOF —

转自:https://mp.weixin.qq.com/s/wuA5_ZV328E5bpSSR0XbiA

FastAPI的小兄弟,开发命令行工具更给力

来源丨经授权转自 未闻Code(ID:itskingname)

作者丨kingname

关注我公众号的同学都知道,我非常喜欢FastAPI这个web框架。它在易用性上面做到了极致,帮助开发者减少了很多不必要的工作。

FastAPI的开发组织叫做tiangolo,他家除了FastAPI外,还有另一个项目也非常好用,叫做typer

三年前,我写过一篇文章一日一技:快速实现Python 命令行参数介绍另一个命令行工具fire. 而typer做得比fire还要好。

首先使用pip来安装它:

python3 -m pip install typer

函数参数等于命令行参数

我们首先来看看typer怎么使用。创建一个example_1.py文件,写入如下代码。

import typer


def main(name: str, salary: int):
    print(f'{name}月薪{salary}元')


if __name__ == '__main__':
    typer.run(main)

直接运行,Python会报错:

FastAPI的小兄弟,开发命令行工具更给力

使用参数--help可以查看这个脚本的命令行参数:

FastAPI的小兄弟,开发命令行工具更给力

于是我们根据这里的提示,输入正确的参数,从而正常运行程序:

FastAPI的小兄弟,开发命令行工具更给力

子命令与自动补全更好用

假设我们有一个神经网络的程序,其中的入口函数代码如下:

def train_data(train_folder: str, test_folder: str, rate: float = 0.8):
    """
    训练人脸检测模型
    """
    print(f'使用文件夹{train_folder}中的数据进行训练')
    print(f'使用{test_folder}中的数据用来验证训练效果,确保准确率>{rate}')
    return True

def predict(folder: str):
    """
    使用训练好的模型预测
    """
    print(f'对文件夹{folder}中的数据进行预测。')

显然,这个程序可以用来训练数据,也可以用来预测数据,所以有两种不同的命令,每一种命令有不同的参数。

这种情况下,使用typer非常方便,只需要加两个装饰器就可以了:

FastAPI的小兄弟,开发命令行工具更给力

运行效果如下图所示:

FastAPI的小兄弟,开发命令行工具更给力

输入具体的子命令,还可以查看每个子命令的参数:

FastAPI的小兄弟,开发命令行工具更给力

因此,我可以使用两个不同的子命令来运行程序:

FastAPI的小兄弟,开发命令行工具更给力

你以为这样就完了?我们再安装它的一个辅助工具typer-cli,还可以做更多事情:

python3 -m pip install typer-cli
typer --install-completion

有了这个东西,我们运行程序可以这样写:

typer example_2.py run 子命令 参数1 参数2 --可选参数1 可选参数1的值

例如:

FastAPI的小兄弟,开发命令行工具更给力

并且,typer可以帮我们可以实现自动补全:

输入typer example_2.py run 然后按下Tab键,自动告诉你可以输入哪些子命令,如下图所示:

FastAPI的小兄弟,开发命令行工具更给力

除此之外,如果你的命令行程序只有一个命令,那么你甚至只需要写一个函数,连typer都不需要导入,就可以使用typer来运行:

FastAPI的小兄弟,开发命令行工具更给力

自动生成文档也简单

我们知道,FastAPI自动生成接口文档的功能非常好用。typer作为它的兄弟,也继承了这个高级功能。我们来看看:

import typer

app = typer.Typer(help="人脸检测模型")


@app.command()
def train_data(train_folder: str, test_folder: str, rate: float = 0.8):
    """
    训练人脸检测模型
    """
    print(f'使用文件夹{train_folder}中的数据进行训练')
    print(f'使用{test_folder}中的数据用来验证训练效果,确保准确率>{rate}')
    return True

@app.command()
def predict(folder: str):
    """
    使用训练好的模型预测
    """
    print(f'对文件夹{folder}中的数据进行预测。')

运行命令:

typer main.py utils docs --name "python3 main.py" --output readme.md

自动在当前文件夹生成一个readme.md文件。我们使用任何能够渲染Markdown的软件打开这个文档,可以看到文档内容如下:

FastAPI的小兄弟,开发命令行工具更给力

这样一来,我们不需要额外花心思去维护文档,只需要在修改完代码、增删新的命令或者参数以后,运行这个命令,就可以把文档自动更新。

转自:https://mp.weixin.qq.com/s/jE5cQtlmXXxJ9-eTpXsW-w

社区发现之标签传播算法(LPA)

在Graph领域,社区发现(Community detection)是一个非常热门且广泛的话题,后面会写一个系列,该问题实际上是从子图分割的问题演变而来,在真实的社交网络中,有些用户之间连接非常紧密,有些用户之间的连接较为稀疏,连接紧密的用户群体可以看做一个社区,在风控问题中,可以简单的理解为团伙挖掘。

目前的社区发现问题分为两大类:非重叠社区发现和重叠社区发现。非重叠社区发现问题描述的是:一个网络中,每个节点均只能属于同一个社区,这意味这社区和社区之间是没有交集的。在非重叠社区发现算法中,有不同种类的解法:
1)基于模块度的社区发现算法:基本思想是通过定义模块度(Modularity)来衡量一个社区的划分是不是相对比较好的结果,从而将社区发现问题转化为最大化模块度的问题进行求解,后续的Louvain算法会讲到。
2)基于标签传播的社区发现算法:基本思想是通过标记节点的标签信息来更新未标记节点的标签信息,在整个网络中进行传播,直至收敛,其中最具代表性的就是标签传播算法(LPA,Label Propagation Algorithm),也是本文要讨论的算法。
注意:在团伙挖掘的实际应用的过程中,不要寄希望于优化社区发现算法提高准确性,可能永远都解决不了问题,因为关系的形成在实际中太过于复杂,我们更多的关注构图关系的筛选、清洗、提纯,以及分群后进一步加工处理
 

一、LPA概述

Label Propagation Algorithm,也称作标签传播算法(LPA),是一个在图中快速发现社群的算法,由Raghavan等人在2007年于论文《Near linear time algorithm to detect community structures in large-scale networks》中提出。在 LPA 算法中,节点的标签完全由它的直接邻居决定。标签传播算法是一种基于标签传播的局部社区发现算法,其基本思想是节点的标签(community)依赖其邻居节点的标签信息,影响程度由节点相似度决定,并通过传播迭代更新达到稳定。

1、算法的思想

在用一个唯一的标签初始化每个节点之后,该算法会重复地将一个节点的标签社群化为该节点的相邻节点中出现频率最高的标签。当每个节点的标签在其相邻节点中出现得最频繁时,算法就会停止。该算法是异步的,因为每个节点都会在不等待其余节点更新的情况下进行更新。
该算法有5个步骤:
1)初始化网络中所有节点的标签,对于给定节点x,Cx(0)=x。
2)设置 t=1。
3)以随机顺序排列网络中的节点,并将其设置为x。
4)对于特定顺序选择的每个x∈X,让Cx(t)=f(Cxi1(t),…,Cxim(t),…。f这里返回相邻标签中出现频率最高的标签。如果有多个最高频率的标签,就随机选择一个标签。
5)如果每个节点都有其邻居节点中数量最多的标签,则停止算法,否则,设置t=t+1并转到3。
这是一个迭代的计算过程且不保证收敛,大体的思路就是每个人都看看自己的邻居都在什么社区内,看看频率最高的社区是啥,如果和自己当前的社区不一样,就把这个最高频社区当成是自己的社区,然后告诉邻居,周而复始,直到对于所有人,邻居们告诉自己的高频社区和自己当前的社区是一样的,算法结束。所以说对于这个算法,计算复杂度是O(kE),k是迭代的次数,E是边的数量。大家的经验是这个迭代的次数大概是5次就能近似收敛,以实现精度和性能的平衡,能发现这个数字和六度分隔理论里面的数字也差不多。
我们可以很形象地理解算法的传播过程,当标签在紧密联系的区域,传播非常快,但到了稀疏连接的区域,传播速度就会下降。当出现一个节点属于多个社群时,算法会使用该节点邻居的标签与权重,决定最终的标签,传播结束后,拥有同样标签的节点被视为在同一群组中。
下图展示了算法的两个变种:Push 和 Pull。其中 Pull 算法更为典型,并且可以很好地并行计算:
社区发现之标签传播算法(LPA)
我们不再继续深入,看完上图,你应该已经理解了算法的大概过程。其实,做过图像处理的人很容易明白,所谓的标签传播算法,不过是图像分割算法的变种,Push 算法是区域生长法(Region Growing)的简化版,而 Pull 更像是分割和合并(divide-and-merge,也有人称 split-merge)算法。确实,图像(image)的像素和图(graph)的节点是十分类似的。

2、用于图聚类

图聚类是根据图的拓扑结构,进行子图的划分,使得子图内部节点的链接较多,子图之间的连接较少。依赖其邻居节点的标签信息,影响程度由节点相似度决定,并通过传播迭代更新达到稳定。
参考原始论文
https://arxiv.org/abs/0709.2938
https://arxiv.org/pdf/0709.2938.pdf
在算法开始之前为每个节点打上不同的标签,每一个轮次随机找到一个节点,查看其邻居节点的标签,找到出现次数最多的标签,随后将该节点改成该标签。当相邻两次迭代后社区数量不变或社区内节点数量不变时则停止迭代,下面看图解过程
初始化
社区发现之标签传播算法(LPA)
第一轮迭代
随机挑选一个节点(如c),发现其相邻节点有abe,三者出现次数相同,故随机选一个(如a),那么c点的标签被a替代。
社区发现之标签传播算法(LPA)
第二轮迭代
随机挑选一个节点(如b),发现其相邻节点均为a,故将b换成a,重复数次,最终的结果如图所示
社区发现之标签传播算法(LPA)
我们再看一个例子,比如下图:
社区发现之标签传播算法(LPA)
分组后的结果如下,我们得到了独立非重的groupid,这个结果其实是很难在实际场景中应用的,那么我们就的结果就没有意义了么?这个可以帮我们定位到浓度很高的群体,然后再加上部分属性标签,就能轻而易举的识别出问题黑产了。
社区发现之标签传播算法(LPA)

3、用于半监督

该算法也可以作为半监督的分类算法,标签传播时一种半监督机器学习算法,它将标签分配给以前未标记的数据点。在算法开始时,数据点的子集(通常只占很小一部分)有标签(或分类)。在整个算法过程中,这些标签会传播到未标记的点。在标签传播过程中,保持已标注数据的标签不变,使其像一个源头把标签传向未标注数据。
最终,当迭代过程结束时,相似节点的概率分布也趋于相似,可以划分到同一个类别中,从而完成标签传播过程,边的权重越大,表示两个节点越相似,那么label越容易传播过去。我们定义一个NxN的概率转移矩阵P:
社区发现之标签传播算法(LPA)
下面的图来看看传播过程
社区发现之标签传播算法(LPA)
传播结束后的结果如下:
社区发现之标签传播算法(LPA)
LPA使用已标记节点的标签作为基础,并尝试预测未标记节点的标签。然而,如果最初的标签是错误的,这可能会影响标签的传播过程,错误的标签可能会被传播。该算法是概率性的,并且发现的社区可能因执行的不同而不同。
 

二、算法代码实现

这个算法比较简单,有比较多的实现方式,最方便的还是networkx这个库,并用里面的一个简单的数据集进行试验。

1、数据集介绍

空手道数据集是一个比较简单的图数据集,下面我们看看其中的边和节点,后面应用这个数据集进行试验。
import networkx as nxG = nx.karate_club_graph() # 空手道G.nodes()NodeView((0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33))
G.edges() EdgeView([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8),(0, 10), (0, 11), (0, 12), (0, 13), (0, 17), (0, 19), (0, 21), (0, 31), (1, 2), (1, 3), (1, 7), (1, 13), (1, 17), (1, 19), (1, 21), (1, 30), (2, 3), (2, 7), (2, 8), (2, 9), (2, 13), (2, 27), (2, 28), (2, 32), (3, 7), (3, 12), (3, 13), (4, 6), (4, 10), (5, 6), (5, 10), (5, 16), (6, 16), (8, 30), (8, 32), (8, 33), (9, 33), (13, 33), (14, 32), (14, 33), (15, 32), (15, 33), (18, 32), (18, 33), (19, 33), (20, 32), (20, 33), (22, 32), (22, 33), (23, 25), (23, 27), (23, 29), (23, 32), (23, 33), (24, 25), (24, 27), (24, 31), (25, 31), (26, 29), (26, 33),(27, 33), (28, 31), (28, 33), (29, 32), (29, 33), (30, 32), (30, 33),(31, 32), (31, 33), (32, 33)])

2、自己实现LPA算法

import randomimport networkx as nximport matplotlib.pyplot as plt # 应该封装成类的形式 def lpa(G): ''' 异步更新方式 G:图 return:None 通过改变节点的标签,最后通过标签来划分社区 算法终止条件:迭代次数超过设定值 ''' max_iter_num = 0 # 迭代次数 while max_iter_num < 10: max_iter_num += 1 print('迭代次数',max_iter_num) for node in G: count = {} # 记录邻居节点及其标签 for nbr in G.neighbors(node): # node的邻居节点 label = G.nodes[nbr]['labels'] count[label] = count.setdefault(label,0) + 1 #找到出现次数最多的标签 count_items = sorted(count.items(),key=lambda x:-x[-1]) best_labels = [k for k,v in count_items if v == count_items[0][1]] #当多个标签最大技术值相同时随机选取一个标签 label = random.sample(best_labels,1)[0] # 返回的是列表,所以需要[0] G.nodes[node]['labels'] = label # 更新标签 def draw_picture(G): # 画图 node_color = [float(G.nodes[v]['labels']) for v in G] pos = nx.spring_layout(G) # 节点的布局为spring型 plt.figure(figsize = (8,6)) # 图片大小 nx.draw_networkx(G,pos=pos,node_color=node_color) plt.show() if __name__ == "__main__": G = nx.karate_club_graph() #空手道数据集 # 给节点添加标签 for node in G: G.add_node(node, labels = node) #用labels的状态 lpa(G) com = set([G.nodes[node]['labels'] for node inG]) print('社区数量',len(com)) draw_picture(G)
迭代次数 1迭代次数 2迭代次数 3迭代次数 4迭代次数 5迭代次数 6迭代次数 7迭代次数 8迭代次数 9迭代次数 10社区数量 3
代码运行结果:
社区发现之标签传播算法(LPA)

3、调包实现LPA算法

networkx集成了这个算法,可以直接调用
import matplotlib.pyplot as pltimport networkx as nxfrom networkx.algorithms.community import asyn_lpa_communities as lpa
# 空手道俱乐部G = nx.karate_club_graph()com = list(lpa(G))print('社区数量',len(com))
com [{0, 1, 2, 3, 7, 8, 9, 11, 12, 13, 17, 19, 21, 30},{4, 5, 6, 10, 16},{14, 15, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 31, 32, 33}]

# 下面是画图pos = nx.spring_layout(G) # 节点的布局为spring型NodeId = list(G.nodes())node_size = [G.degree(i)**1.2*90 for i in NodeId] # 节点大小
plt.figure(figsize = (8,6)) # 设置图片大小nx.draw(G,pos, with_labels=True, node_size =node_size, node_color='w', node_shape = '.' )
'''node_size表示节点大小node_color表示节点颜色with_labels=True表示节点是否带标签'''color_list = ['pink','orange','r','g','b','y','m','gray','black','c','brown']
for i in range(len(com)): nx.draw_networkx_nodes(G, pos, nodelist=com[i], node_color = color_list[i+2], label=True)plt.show()
社区发现之标签传播算法(LPA)

三、分群结果可视化

在可视化方面,确实R语言要强,大家有时间可以学习下,活儿全还是有点用处的,我们这里用R的igraph包来展现一些社区发现的结果。
library('igraph')karate <- graph.famous("Zachary")community <- label.propagation.community(karate)# 计算模块度modularity(community)0.3717949
#membership查看每个点的各自分组情况。membership(community)1 1 1 1 1 1 1 1 2 1 1 1 1 1 2 2 1 1 2 1 2 1 2 2 2 2 2 2 2 2 2 2 2 2
plot(community,karate)
下面为两次跑的结果,可以看到,两次的结果并不一样,这个就是震荡效应导致的结果
社区发现之标签传播算法(LPA)
换一个对比下看看
community <- walktrap.community(karate, weights = E(karate)$weight, steps = 8, merges =TRUE, modularity = TRUE)plot(community,karate)
社区发现之标签传播算法(LPA)
可以用更复杂的数据,画出来还挺好看的,数据集的下载地址:http://snap.stanford.edu/data/egonets-Facebook.html
library(igraph)library(d3Network)igraphDat <- read.graph(file = "/Users/wuzhengxiang/Documents/PPT模板/0.edges", directed = FALSE)
## Simplify to remove duplications and from-self-to-self loopsigraphDat <- simplify(igraphDat, remove.multiple = TRUE, remove.loops = TRUE )
## Give numbersV(igraphDat)$label <- seq_along(V(igraphDat))
## Average path length between any two given nodes(averagePathLength <- average.path.length(igraphDat))
## Community structure detection based on edge betweennesscommunityEdgeBetwn <- edge.betweenness.community(igraphDat)
## Check the transitivity of a graph (probability that the adjacent vertices of a vertex are connected)(transitivityDat <- transitivity(igraphDat, type = "localaverage", isolates = "zero") )
## Set the seed to get the same resultset.seed("20200513")
## Add community indicating background colorsplot(igraphDat,vertex.color = communityEdgeBetwn$membership, vertex.size = log(degree(igraphDat) + 1),mark.groups = by(seq_along(communityEdgeBetwn$membership), communityEdgeBetwn$membership, invisible) )
## Annotatetitle("Stanford Facebook data", sub = "http://snap.stanford.edu/data/egonets-Facebook.html" )text(x = -1, y = -1, labels = sprintf("Average path length: %.2fnTransitivity: %.2f", averagePathLength, transitivityDat) )
社区发现之标签传播算法(LPA)
社区发现之标签传播算法(LPA)
社区发现之标签传播算法(LPA)

四、算法优缺点

作为一个比较简单的算法,其优缺点也是特别的明显。

1、算法优点

算法逻辑简单,时间复杂度低,接近线性复杂度,在超大规模网络下会有优异的性能,适合做社区发现的baseline。
无须定义优化函数,无须事先指定社区个数,算法会利用自身的网络结构来指导标签传播。

2、算法缺点

雪崩效应:社区结果不稳定,随机性强。由于当邻居节点的社区标签权重相同时,会随机取一个。导致传播初期一个小的错误被不断放大,最终没有得到合适的结果。尤其是异步更新时,更新顺序的不同也会导致最终社区划分结果不同。
社区发现之标签传播算法(LPA)
上图中展示了一次标签传播算法的流程:初始化阶段,每个节点都以自己作为社区标签。比如a的社区就是a,c的社区就是c。当进入传播阶段,节点c的邻居节点共4个:a,b,c,d。而社区标签也是4个:a,b,c,d,假设随机取了一个a。
如果是异步更新,此时b,d,e三个节点的邻居节点中社区标签均存在2个a,所以他们都会立马更新成a。如果c当时随机选择的是b,那么d,e就会更新成b,从而导致b社区标签占优,而最终的社区划分也就成b了。
震荡效应:社区结果来回震荡,不收敛,当传播方式处于同步更新的时候,尤其对于二分图或子图存在二分图的结构而言,极易发生。
社区发现之标签传播算法(LPA)
上图中展示了一次二分图中标签传播算法的流程,在同步更新的时候,每个节点依赖的都是上一轮迭代的社区标签。当二分图左边都是a,右边都是b时,a社区的节点此时邻居节点都是b,b社区的节点此时邻居节点都是a,根据更新规则,此时a社区的节点将全部更新为b,b社区的节点将全部更新为a。此时算法无法收敛,使得整个网络处于震荡中。
转自:https://mp.weixin.qq.com/s/DgCK9Ea-Qf00KyB1W8x8Iw

如何用 Python 捕获、播放和保存摄像头视频

今天先分享一下 Python 操作视频最基本的操作,包括读取和播放视频和保存视频。

读取视频

要捕获视频,你需要创建一个 VideoCapture 对象。它的参数可以是设备索引或视频文件的名称。所以,我们读取视频有两种方式,分别是从相机中读取视频和从文件中读取视频。

从相机中读取视频

对于有摄像头的设备,例如带摄像头的笔记本电脑,我们可以直接调起电脑的摄像头,读取摄像头的视频流。

import cv2 as cv
cap = cv.VideoCapture(0)
if not cap.isOpened():
    print("Cannot open camera")
    exit()
while True:
    # 逐帧捕获
    ret, frame = cap.read()
    # 如果正确读取帧,ret为True
    if not ret:
        break
    # 显示结果帧
    cv.imshow('frame', frame)
    if cv.waitKey(1) == ord('q'):
        break
# 完成所有操作后,释放捕获器
cap.release()
cv.destroyAllWindows()

这里我向 VideoCapture 对象传入了参数 0,表示设备索引,设备索引就是指定哪个摄像头的数字。正常情况下,一个摄像头会被连接(就像我的情况一样)。所以我简单地传0。你可以通过传递1来选择第二个相机,以此类推。

cap.isOpened() 用来判断是否捕获到视频。

cap.read() 返回布尔值(True/ False)。如果正确读取了帧,它将为True。因此,你可以通过检查此返回值来检查视频的结尾。

cv.imshow 方法用来显示视频的帧。我们播放视频的原理就是逐帧播放。

在最后,不要忘记通过 cap.release() 释放俘虏。

运行这段代码,你就可以看到一个弹窗实时地播放你电脑摄像头中的图像了。

从文件中播放视频

与从相机捕获相同,只是用视频文件名更改摄像机索引。

另外,在显示视频时,可以通过 cv.waitKey() 来控制视频播放的速度。如果设置太小,则视频将非常快,相当于倍速播放;而如果太大,则视频将变得很慢,相当于延迟播放。正常情况下25毫秒就可以了。

import cv2 as cv
cap = cv.VideoCapture('video.mp4')
while cap.isOpened():
    ret, frame = cap.read()
    # 如果正确读取帧,ret为True
    if not ret:
        break
    cv.imshow('frame', frame)
    if cv.waitKey(1) == ord('q'):
        break
cap.release()
cv.destroyAllWindows()

运行这段代码,你就可以看到一个弹窗播放你选择的视频文件了。

保存视频

从相机读取视频,我们可以将视频保存到本地。我们捕捉一个视频,一帧一帧地处理,如果我们想要保存这个视频,非常简单,只需使用 cv.VideoWriter()

cv.VideoWriter() 有5个参数:

  • 参数1:输出文件名,例如: output.mp4。
  • 参数2:FourCC 代码,FourCC 是用于指定视频编解码器的4字节代码。
  • 参数3:帧率的数量。
  • 参数4:帧大小。
  • 参数5:颜色标志。如果为 True,正常颜色输出,否则就是灰色图像输出。

关于 FourCC 与视频格式的对照关系,我列举了一些常见的格式:

cv2.VideoWriter_fourcc(‘P’,‘I’,‘M’,‘1’) = MPEG-1 codec cv2.VideoWriter_fourcc(‘M’,‘J’,‘P’,‘G’) = motion-jpeg codec –> mp4v cv2.VideoWriter_fourcc(‘M’, ‘P’, ‘4’, ‘2’) = MPEG-4.2 codec cv2.VideoWriter_fourcc(‘D’, ‘I’, ‘V’, ‘3’) = MPEG-4.3 codec cv2.VideoWriter_fourcc(‘D’, ‘I’, ‘V’, ‘X’) = MPEG-4 codec –> avi cv2.VideoWriter_fourcc(‘U’, ‘2’, ‘6’, ‘3’) = H263 codec cv2.VideoWriter_fourcc(‘I’, ‘2’, ‘6’, ‘3’) = H263I codec cv2.VideoWriter_fourcc(‘F’, ‘L’, ‘V’, ‘1’) = FLV1 codec

保存视频的代码:

import cv2 as cv
cap = cv.VideoCapture(0)
# 定义编解码器并创建VideoWriter对象
fourcc = cv.VideoWriter_fourcc(*'MJPG')
out = cv.VideoWriter('output.mp4', fourcc, 20.0, (640,  480))
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    frame = cv.flip(frame, 1)
    # 写翻转的框架
    out.write(frame)
    cv.imshow('frame', frame)
    if cv.waitKey(1) == ord('q'):
        break
# 完成工作后释放所有内容
cap.release()
out.release()
cv.destroyAllWindows()

运行这段代码,你就可以在代码目录下找到一个 output.mp4 的视频文件了。

上面几段代码中,如果想要退出视频操作,敲击键盘的 q 就可以。

总结

以上就是今天要介绍的内容了,使用 python-opencv 来操作视频还是比较简单的。当然,你也可以在读取或者保存视频时对视频进行一些处理,这个我们后续再发文介绍。

转自:https://mp.weixin.qq.com/s/FvaJKnYn1QTRX8a9jdwD-g

警惕!Python 中少为人知的 10 个安全陷阱!

Python 开发者们在使用标准库和通用框架时,都以为自己的程序具有可靠的安全性。然而,在 Python 中,就像在任何其它编程语言中一样,有一些特性可能会被开发者们误解或误用。通常而言,只有极少的微妙之处或细节会使开发者们疏忽大意,从而在代码中引入严重的安全漏洞。

在这篇博文中,我们将分享在实际 Python 项目中遇到的 10 个安全陷阱。我们选择了一些在技术圈中不太为人所知的陷阱。通过介绍每个问题及其造成的影响,我们希望提高人们对这些问题的感知,并提高大家的安全意识。如果你正在使用这些特性,请一定要排查你的 Python 代码!

1.被优化掉的断言

Python 支持以优化的方式执行代码。这使代码运行得更快,内存用得更少。当程序被大规模使用,或者可用的资源很少时,这种方法尤其有效。一些预打包的 Python 程序提供了优化的字节码。

然而,当代码被优化时,所有的 assert 语句都会被忽略。开发者有时会使用它们来判断代码中的某些条件。例如,如果使用断言来作身份验证检查,则可能导致安全绕过。

def superuser_action(request, user):
    assert user.is_super_user
    # execute action as super user

在这个例子中,第 2 行中的 assert 语句将被忽略,导致非超级用户也可以运行到下一行代码。不推荐使用 assert 语句进行安全相关的检查,但我们确实在实际的项目中看到过它们。

2. MakeDirs 权限

os.makdirs 函数可以在操作系统中创建一个或多个文件夹。它的第二个参数 mode 用于指定创建的文件夹的默认权限。在下面代码的第 2 行中,文件夹 A/B/C 是用 rwx—— (0o700) 权限创建的。这意味着只有当前用户(所有者)拥有这些文件夹的读、写和执行权限。

def init_directories(request):
    os.makedirs("A/B/C", mode=0o700)
    return HttpResponse("Done!")

在 Python < 3.6 版本中,创建出的文件夹 A、B 和 C 的权限都是 700。但是,在 Python > 3.6 版本中,只有最后一个文件夹 C 的权限为 700,其它文件夹 A 和 B 的权限为默认的 755。

因此,在 Python > 3.6 中,os.makdirs 函数等价于 Linux 的这条命令:mkdir -m 700 -p A/B/C。有些开发者没有意识到版本之间的差异,这已经在 Django 中造成了一个权限越级漏洞(cve – 2022 -24583),无独有偶,这在 WordPress 中也造成了一个加固绕过问题。

3.绝对路径拼接

os.path.join(path, *paths) 函数用于将多个文件路径连接成一个组合的路径。第一个参数通常包含了基础路径,而之后的每个参数都被当做组件拼接到基础路径后。

然而,这个函数有一个少有人知的特性。如果拼接的某个路径以 / 开头,那么包括基础路径在内的所有前缀路径都将被删除,该路径将被视为绝对路径。下面的示例揭示了开发者可能遇到的这个陷阱。

def read_file(request):
    filename = request.POST['filename']
    file_path = os.path.join("var""lib", filename)
    if file_path.find(".") != -1:
        return HttpResponse("Failed!")
    with open(file_path) as f:
        return HttpResponse(f.read(), content_type='text/plain')

在第 3 行中,我们使用 os.path.join 函数将用户输入的文件名构造出目标路径。在第 4 行中,检查生成的路径是否包含”.“,防止出现路径遍历漏洞。

但是,如果攻击者传入的文件名参数为”/a/b/c.txt“,那么第 3 行得到的变量 file_path 会是一个绝对路径(/a/b/c.txt)。即 os.path.join 会忽略掉”var/lib“部分,攻击者可以不使用“.”字符就读取到任何文件。尽管 os.path.join 的文档中描述了这种行为,但这还是导致了许多漏洞(Cuckoo Sandbox Evasion, CVE-2020-35736)。

4. 任意的临时文件

tempfile.NamedTemporaryFile 函数用于创建具有特定名称的临时文件。但是,prefix(前缀)和 suffix(后缀)参数很容易受到路径遍历攻击(Issue 35278)。如果攻击者控制了这些参数之一,他就可以在文件系统中的任意位置创建出一个临时文件。下面的示例揭示了开发者可能遇到的一个陷阱。

def touch_tmp_file(request):
    id = request.GET['id']
    tmp_file = tempfile.NamedTemporaryFile(prefix=id)
    return HttpResponse(f"tmp file: {tmp_file} created!", content_type='text/plain')

在第 3 行中,用户输入的 id 被当作临时文件的前缀。如果攻击者传入的 id 参数是“/../var/www/test”,则会创建出这样的临时文件:/var/www/test_zdllj17。粗看起来,这可能是无害的,但它会为攻击者创造出挖掘更复杂的漏洞的基础。

5.扩展的 Zip Slip

在 Web 应用中,通常需要解压上传后的压缩文件。在 Python 中,很多人都知道 TarFile.extractall 与 TarFile.extract 函数容易受到 Zip Slip 攻击。攻击者通过篡改压缩包中的文件名,使其包含路径遍历(../)字符,从而发起攻击。

这就是为什么压缩文件应该始终被视为不受信来源的原因。zipfile.extractall 与 zipfile.extract 函数可以对 zip 内容进行清洗,从而防止这类路径遍历漏洞。

但是,这并不意味着在 ZipFile 库中不会出现路径遍历漏洞。下面是一段解压缩文件的代码。

def extract_html(request):
    filename = request.FILES['filename']
    zf = zipfile.ZipFile(filename.temporary_file_path(), "r")
    for entry in zf.namelist():
        if entry.endswith(".html"):
            file_content = zf.read(entry)
            with open(entry, "wb"as fp:
                fp.write(file_content)
    zf.close()
    return HttpResponse("HTML files extracted!")

第 3 行代码根据用户上传文件的临时路径,创建出一个 ZipFile 处理器。第 4 – 8 行代码将所有以“.html”结尾的压缩项提取出来。第 4 行中的 zf.namelist 函数会取到 zip 内压缩项的名称。注意,只有 zipfile.extract 与 zipfile.extractall 函数会对压缩项进行清洗,其它任何函数都不会。

在这种情况下,攻击者可以创建一个文件名,例如“../../../var/www/html”,内容随意填。该恶意文件的内容会在第 6 行被读取,并在第 7-8 行写入被攻击者控制的路径。因此,攻击者可以在整个服务器上创建任意的 HTML 文件。

如上所述,压缩包中的文件应该被看作是不受信任的。如果你不使用 zipfile.extractall 或者 zipfile.extract,你就必须对 zip 内文件的名称进行“消毒”,例如使用 os.path.basename。否则,它可能导致严重的安全漏洞,就像在 NLTK Downloader (CVE-2019-14751)中发现的那样。

6. 不完整的正则表达式匹配

正则表达式(regex)是大多数 Web 程序不可或缺的一部分。我们经常能看到它被自定义的 Web 应用防火墙(WAF,Web Application Firewalls)用来作输入验证,例如检测恶意字符串。在 Python 中,re.match 和 re.search 之间有着细微的区别,我们将在下面的代码片段中演示。

def is_sql_injection(request):
    pattern = re.compile(r".*(union)|(select).*")
    name_to_test = request.GET['name']
    if re.search(pattern, name_to_test):
        return True
    return False

在第 2 行中,我们定义了一个匹配 union 或者 select 的模式,以检测可能的 SQL 注入。这是一个糟糕的写法,因为你可以轻易地绕过这些黑名单,但我们已经在线上的程序中见过它。在第 4 行中,函数 re.match 使用前面定义好的模式,检查第 3 行中的用户输入内容是否包含这些恶意的值。

然而,与 re.search 函数不同的是,re.match 函数不匹配新行。例如,如果攻击者提交了值 aaaaaa n union select,这个输入就匹配不上正则表达式。因此,检查可以被绕过,失去保护作用。

总而言之,我们不建议使用正则表达式黑名单进行任何安全检查。

7. Unicode 清洗器绕过

Unicode 支持用多种形式来表示字符,并将这些字符映射到码点。在 Unicode 标准中,不同的 Unicode 字符有四种归一化方案。程序可以使用这些归一化方法,以独立于人类语言的标准方式来存储数据,例如用户名。

然而,攻击者可以利用这些归一化,这已经导致了 Python 的 urllib 出现漏洞(CVE-2019-9636)。下面的代码片段演示了一个基于 NFKC 归一化的跨站点脚本漏洞(XSS,Cross-Site Scripting)。

import unicodedata
from django.shortcuts import render
from django.utils.html import escape

def render_input(request):
    user_input = escape(request.GET['p'])
    normalized_user_input = unicodedata.normalize("NFKC", user_input)
    context = {'my_input': normalized_user_input}
    return render(request, 'test.html', context)

在第 6 行中,用户输入的内容被 Django 的 escape 函数处理了,以防止 XSS 漏洞。在第 7 行中,经过清洗的输入被 NFKC 算法归一化,以便在第 8-9 行中通过 test.html 模板正确地渲染。

templates/test.html

<!DOCTYPE html>
<html lang="en">
<body>
{{ my_input | safe}}
</body>
</html>

在模板 test.html 中,第 4 行的变量 my_input 被标记为安全的,因为开发人员预期有特殊字符,并且认为该变量已经被 escape 函数清洗了。通过标记关键字 safe, Django 不会再次对变量进行清洗。

但是,由于第 7 行(view.py)的归一化,字符“%EF%B9%A4”会被转换为“<”,“%EF%B9%A5”被转换为“>”。这导致攻击者可以注入任意的 HTML 标记,进而触发 XSS 漏洞。为了防止这个漏洞,就应该在把用户输入做完归一化之后,再进行清洗。

8. Unicode 编码碰撞

前文说过,Unicode 字符会被映射成码点。然而,有许多不同的人类语言,Unicode 试图将它们统一起来。这就意味着不同的字符很有可能拥有相同的“layout”。例如,小写的土耳其语 ı(没有点)的字符是英语中大写的 I。在拉丁字母中,字符 i 也是用大写的 I 表示。在 Unicode 标准中,这两个不同的字符都以大写形式映射到同一个码点。

这种行为是可以被利用的,实际上已经在 Django 中导致了一个严重的漏洞(CVE-2019-19844)。下面的代码是一个重置密码的示例。

from django.core.mail import send_mail
from django.http import HttpResponse
from vuln.models import User

def reset_pw(request):
    email = request.GET['email']
    result = User.objects.filter(email__exact=email.upper()).first()
    if not result:
        return HttpResponse("User not found!")
    send_mail('Reset Password','Your new pw: 123456.''from@example.com', [email], fail_silently=False)
    return HttpResponse("Password reset email send!")

第 6 行代码获取了用户输入的 email,第 7-9 行代码检查这个 email 值,查找是否存在具有该 email 的用户。如果用户存在,则第 10 行代码依据第 6 行中输入的 email 地址,给用户发送邮件。需要指出的是,第 7-9 行中对邮件地址的检查是不区分大小写的,使用了 upper 函数。

至于攻击,我们假设数据库中存在一个邮箱地址为 foo@mix.com 的用户。那么,攻击者可以简单地传入 foo@mıx.com 作为第 6 行中的 email,其中 i 被替换为土耳其语 ı。第 7 行代码将邮箱转换成大写,结果是 FOO@MIX.COM。这意味着找到了一个用户,因此会发送一封重置密码的邮件。

然而,邮件被发送到第 6 行未转换的邮件地址,也就是包含了土耳其语的 ı。换句话说,其他用户的密码被发送到了攻击者控制的邮件地址。为了防止这个漏洞,可以将第 10 行替换成使用数据库中的用户邮箱。即使发生编码冲突,攻击者在这种情况下也得不到任何好处。

9. IP 地址归一化

在 Python < 3.8 中,IP 地址会被 ipaddress 库归一化,因此前缀的零会被删除。这种行为乍一看可能是无害的,但它已经在 Django 中导致了一个高严重性的漏洞(CVE-2021-33571)。攻击者可以利用归一化绕过校验程序,发起服务端请求伪造攻击(SSRF,Server-Side Request Forgery)。

下面的代码展示了如何绕过这样的校验器。

import requests
import ipaddress

def send_request(request):
    ip = request.GET['ip']
    try:
        if ip in ["127.0.0.1""0.0.0.0"]:
            return HttpResponse("Not allowed!")
        ip = str(ipaddress.IPv4Address(ip))
    except ipaddress.AddressValueError:
        return HttpResponse("Error at validation!")
    requests.get('https://' + ip)
    return HttpResponse("Request send!")

第 5 行代码获取用户传入的一个 IP 地址,第 7 行代码使用一个黑名单来检查该 IP 是否为本地地址,以防止可能的 SSRF 漏洞。这份黑名单并不完整,仅作为示例。

第 9 行代码检查该 IP 是否为 IPv4 地址,同时将 IP 归一化。在完成验证后,第 12 行代码会对该 IP 发起实际的请求。

但是,攻击者可以传入 127.0.001 这样的 IP 地址,在第 7 行的黑名单列表中找不到。然后,第 9 行代码使用 ipaddress.IPv4Address 将 IP 归一化为 127.0.0.1。因此,攻击者就能够绕过 SSRF 校验器,并向本地网络地址发送请求。

10. URL 查询参数解析

在 Python < 3.7 中,urllib.parse.parse_qsl 函数允许使用“;”和“&”字符作为 URL 的查询变量的分隔符。有趣的是“;”字符不能被其它语言识别为分隔符。

在下面的例子中,我们将展示为什么这种行为会导致漏洞。假设我们正在运行一个基础设施,其中前端是一个 PHP 程序,后端则是一个 Python 程序。

攻击者向 PHP 前端发送以下的 GET 请求:

GET https://victim.com/?a=1;b=2

PHP 前端只识别出一个查询参数“a”,其内容为“1;b=2”。PHP 不把“;”字符作为查询参数的分隔符。现在,前端会将攻击者的请求直接转发给内部的 Python 程序:

GET https://internal.backend/?a=1;b=2

如果使用了 urllib.parse.parse_qsl,Python 程序会处理成两个查询参数,即“a=1”和“b=2”。这种查询参数解析的差异可能会导致致命的安全漏洞,比如 Django 中的 Web 缓存投毒漏洞(CVE-2021-23336)。

总结

在这篇博文中,我们介绍了 10 个 Python 安全陷阱,我们认为开发者不太了解它们。每个细微的陷阱都很容易被忽视,并在过去导致了线上程序的安全漏洞。

正如前文所述,安全陷阱可能出现在各种操作中,从处理文件、目录、压缩文件、URL、IP 到简单的字符串。一种常见的情况是库函数的使用,这些函数可能有意想不到的行为。这提醒我们一定要升级到最新版本,并仔细阅读文档。在 SonarSource 中,我们正在研究这些缺陷,以便将来不断改进我们的代码分析器。

英文作者:Dennis Brinkrolf,译者:豌豆花下猫

英文:https://blog.sonarsource.com/10-unknown-security-pitfalls-for-python

转自:https://mp.weixin.qq.com/s/4ZjsOv1XlgJU0iXtjBorKg